2. 程式人生 > 其它 >java 多執行緒按順序執行、順序獲取結果

java 多執行緒按順序執行、順序獲取結果

阿新 • • 發佈：2020-12-13

技術標籤：Android面試多執行緒java順序面試

文章目錄

1、通過Thread的join方法

join主要是讓父執行緒等待子執行緒結束之後父執行緒才能繼續執行

    public static void main(String[] args) throws InterruptedException {
        System.out.println("---開啟執行緒1---");
        MyThread t1 = new MyThread("執行緒1");
        t1.start();
        t1.join();

        System.out.println("---開啟執行緒2---");
        MyThread t2 = new MyThread("執行緒2");
        t2.start();
        t2.join();

        System.out.println("---開啟執行緒3---");
        MyThread t3 = new MyThread("執行緒3");
        t3.start();
        t3.join();
        
    }
    
    static class MyThread extends Thread {
        public MyThread(String name){
            super(name);
        }
        @Override
        public void run() {
            super.run();
            System.out.println(Thread.currentThread().getName()+"執行了");
        }
    }

列印結果

---開啟執行緒1---
執行緒1執行了
---開啟執行緒2---
執行緒2執行了
---開啟執行緒3---
執行緒3執行了

2、FutureTask

   public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---開啟執行緒1---");
        FutureTask<String> f1 = new FutureTask<>(new MyCall());
        Thread t1 = new Thread(f1,"執行緒1");
        t1.start();
        System.out.println("執行緒1返回結果： " + f1.get());

        System.out.println("---開啟執行緒2---");
        FutureTask<String> f2 = new FutureTask<>(new MyCall());
        Thread t2 = new Thread(f2,"執行緒2");
        t2.start();
        System.out.println("執行緒2返回結果： " + f2.get());

        System.out.println("---開啟執行緒3---");
        FutureTask<String> f3 = new FutureTask<>(new MyCall());
        Thread t3 = new Thread(f3,"執行緒3");
        t3.start();
        System.out.println("執行緒3返回結果： " + f3.get());
    }
    
    
    static class MyCall implements Callable<String> {
        @Override
        public String call() throws Exception {
            return Thread.currentThread().getName();
        }
    }

列印結果

---開啟執行緒1---
執行緒1返回結果： 執行緒1
---開啟執行緒2---
執行緒2返回結果： 執行緒2
---開啟執行緒3---
執行緒3返回結果： 執行緒3

3、CountDownLatch（倒計數）

現在有如下3個執行緒

   public static void main(String[] args) throws InterruptedException, ExecutionException {

        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("執行緒1執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "執行緒1");
        t1.start();

        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(200);
                    System.out.println("執行緒2執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "執行緒2");
        t2.start();

        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    System.out.println("執行緒3執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒3");
        t3.start();
    }

它們的執行結果是

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒3執行了。。。
執行緒2執行了。。。
執行緒1執行了。。。

上面的輸出是按照3、2、1輸出的。如果現在要按照1、2、3的順序進行輸出，每個執行緒的sleep時間不能修改，該如何去處理？可以藉助CountDownLatch

    private static CountDownLatch c1 = new CountDownLatch(1);
    private static CountDownLatch c2 = new CountDownLatch(1);
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("執行緒1執行了。。。");
                    c1.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "執行緒1");
        t1.start();

        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c1.await();
                    Thread.sleep(200);
                    System.out.println("執行緒2執行了。。。");
                    c2.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "執行緒2");
        t2.start();

        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c2.await();
                    Thread.sleep(100);
                    System.out.println("執行緒3執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒3");
        t3.start();
    }

它們的執行結果是

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒1執行了。。。
執行緒2執行了。。。
執行緒3執行了。。。

4、wait、notify

    private final static Object lock1 = new Object();
    private final static Object lock2 = new Object();
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        lock1.wait();
                        Thread.sleep(500);
                        System.out.println("執行緒1執行了。。。");
                        lock1.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "執行緒1");
        t1.start();
        Thread.sleep(10);//這個主要保證執行緒開啟的順序
        
        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        lock1.notify();
                        lock1.wait();
                        Thread.sleep(200);
                        System.out.println("執行緒2執行了。。。");
                        synchronized (lock2) {
                            lock2.notify();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }, "執行緒2");
        t2.start();
        Thread.sleep(10);
        
        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock2) {
                    try {
                        lock2.wait();
                        Thread.sleep(100);
                        System.out.println("執行緒3執行了。。。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "執行緒3");
        t3.start();

    }

列印結果

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒1執行了。。。
執行緒2執行了。。。
執行緒3執行了。。。

5、Condition(條件變數)

    private static Lock lock = new ReentrantLock();
    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition1.await();
                    Thread.sleep(500);
                    System.out.println("執行緒1執行了。。。");
                    condition1.signal();
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒1");
        t1.start();

        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition1.signal();
                    condition1.await();
                    Thread.sleep(200);
                    System.out.println("執行緒2執行了。。。");
                    condition2.signal();
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒2");
        t2.start();

        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition2.await();
                    Thread.sleep(100);
                    System.out.println("執行緒3執行了。。。");
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒3");
        t3.start();
    }

列印結果

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒1執行了。。。
執行緒2執行了。。。
執行緒3執行了。。。

6、CyclicBarrier(迴環柵欄)

    private static CyclicBarrier barrier1 = new CyclicBarrier(2);
    private static CyclicBarrier barrier2 = new CyclicBarrier(2);

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("執行緒1執行了。。。");
                    barrier1.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒1");
        t1.start();

        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    barrier1.await();
                    Thread.sleep(200);
                    System.out.println("執行緒2執行了。。。");
                    barrier2.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒2");
        t2.start();

        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    barrier2.await();
                    Thread.sleep(100);
                    System.out.println("執行緒3執行了。。。");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒3");
        t3.start();
    }

列印結果

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒1執行了。。。
執行緒2執行了。。。
執行緒3執行了。。。

5、執行緒池

5.1、單執行緒化執行緒池

    private static ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---開啟執行緒1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("執行緒1執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒1");


        System.out.println("---開啟執行緒2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(200);
                    System.out.println("執行緒2執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒2");


        System.out.println("---開啟執行緒3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    System.out.println("執行緒3執行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "執行緒3");
        executorService.submit(t1);
        executorService.submit(t2);
        executorService.submit(t3);
    }

列印結果

---開啟執行緒1---
---開啟執行緒2---
---開啟執行緒3---
執行緒1執行了。。。
執行緒2執行了。。。
執行緒3執行了。。。

5.2、多執行緒化執行緒池

其實最常見的還是使用多執行緒化的執行緒池去實現。

    private static ExecutorService executorService = Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        ArrayList<Future<String>> futureList = new ArrayList<Future<String>>();
        ArrayList<String> names = new ArrayList<String>();
        for (int i = 0; i < 3; i++) {
            futureList.add(executorService.submit(new MyCall(i + "")));
        }

        for (int i = 0; i < 3; i++) {
            Future<String> future = futureList.get(i);
            String value = future.get();
            System.out.println("執行緒"+value+"執行了");
        }
        long spendTime = System.currentTimeMillis() - start;
        System.out.println("花費時間---"+spendTime);

    }
    
    
    static class MyCall implements Callable<String> {
        private String name;

        public MyCall(String name) {
            this.name = name;
        }

        @Override
        public String call() throws Exception {
            switch (name){
                case "0":
                    Thread.sleep(3000);
                    break;
                case "1":
                    Thread.sleep(2000);
                    break;
                case "2":
                    Thread.sleep(1000);
                    break;
            }

            return name;
        }
    }

列印結果

執行緒0執行了
執行緒1執行了
執行緒2執行了
花費時間---3006

常見的問題：

  • 1、2、3總共3個執行緒，按順序請求，按順序取結果。
  • 1、2、3總共3個執行緒，執行緒3要等到執行緒1和2執行完才能執行，執行緒1和2是並行的。
  • 寫一個多執行緒程式，交替輸出1,2,1,2,1,2

相信上面的問題應該不難了。。

在這裡插入圖片描述

相關推薦

java 多執行緒按順序執行、順序獲取結果

技術標籤：Android面試多執行緒java順序面試 文章目錄 1、通過Thread的join方法2、FutureTask3、CountDownLatch（倒計數）4、wait、notify5、Condition(條件變數)6、CyclicBarrier(迴環柵欄)5、執行緒池5.1、單

Java多執行緒按指定順序同步執行

筆者今天看到一個有趣的面試題，如何讓多個執行緒按照既定的順序依次執行？比如每個執行緒輸出一個整數，

Java 多執行緒（Java.Thread）-----執行緒休眠(Thread.Sleep)、執行緒禮讓（Thread.Yield）和執行緒阻塞（Thread.Join）

技術標籤：Java基礎 執行緒休眠(Thread.Sleep) sleep(時間)指定當前執行緒阻塞的毫秒數sleep存在異常InterruptedExceptionsleep時間達到後執行緒進入就緒狀態sleep可以模擬網路延時，倒計時等每一個物件都有一個

多執行緒按順序列印數字

多執行緒按順序列印數字： 示例結題如下： A執行緒列印：1 B執行緒列印：2 C執行緒列印：3

淺析Java對集合進行操作時報java.util.ConcurrentModificationException併發修改異常問題：產生原因、單執行緒/多執行緒環境解決、CopyOnWriteArrayList執行緒安全的ArrayList、fail-fast快速失敗機制防止多執行緒修改集合造成併發問題

一、異常產生 　　當我們迭代一個ArrayList或者HashMap時，如果嘗試對集合做一些修改操作（例如刪除元素），可能會丟擲java.util.ConcurrentModificationException的異常。

C++ 多執行緒按順序執行函式

C++ 多執行緒按順序執行函式的常用操作。 我們提供了一個類： public class Foo { public void first() { print(\"first\"); }

Java多執行緒04：執行緒優先順序、守護執行緒和執行緒同步

Java多執行緒04：執行緒優先順序、守護執行緒和執行緒同步 執行緒優先順序 Java提供一個執行緒排程器來監控程式中啟動後進入就緒狀態的所有執行緒，執行緒排程器按照優先順序決定應該排程哪個執行緒來執行

Java執行緒狀態及切換、關閉執行緒的正確姿勢分享

前言 在講執行緒之前有必要討論一下程序的定義：程序是程式在一個數據集合上執行的過程，它是系統進行資源分配和排程的一個獨立單位。程序實體由程式段， 資料段 PCB（程序控制塊）組成。執行緒又是什麼？執行緒可以

Python多執行緒Threading、子執行緒與守護執行緒例項詳解

本文例項講述了Python多執行緒Threading、子執行緒與守護執行緒。分享給大家供大家參考，具體如下：

淺談Python3多執行緒之間的執行順序問題

一個多執行緒的題：定義三個執行緒ID分別為ABC，每個執行緒列印10遍自己的執行緒ID，按ABCABC……的順序進行列印輸出。

深入分析JAVA 多執行緒--interrupt()和執行緒終止方式

一、interrupt() 介紹 interrupt() 定義在 Thread 類中，作用是中斷本執行緒。 本執行緒中斷自己是被允許的；其它執行緒呼叫本執行緒的 interrupt() 方法時，會通過 checkAccess() 檢查許可權。這有可能丟擲 Securit

【C++多執行緒】std::future、std::async、std::promise、std::packaged_task、std::shared_future

　　如圖以下是標頭檔案<future>中的類容。 std::future<T> 　　future有兩個類模板，一個獨佔的std::future，也就是隻能被獲取一次，另一個是共享的std::shared_future。std::future<T>是一個類

Java多執行緒--兩個執行緒同時對一個人的年齡進行增加和修改

1 public class Thread_A extends Thread { 2Human human; 3 4public Thread_A(String name, Human human) {

Java執行緒知識：二、鎖的簡單使用（轉載）

Java執行緒知識：二、鎖的簡單使用 鎖的初步認識 說到鎖，相信大家都不陌生，這是我們生活中非常常見的一種東西，它的形狀也各式各樣。在生活中，我們通常用鎖來鎖住房子的大門、裝寵物的籠子、裝衣服的衣櫃、以

java中四種執行緒池及poolSize、corePoolSize、maximumPoolSize

Executors提供四種執行緒池： newCachedThreadPool ：快取執行緒池，如果執行緒池長度超過處理需要，可回收空閒執行緒，若無可回收，則新建執行緒。

多執行緒按序列印1-100

1.兩個執行緒交替列印 public class Main { volatile int flag=0; public static void main(String[] args) throws InterruptedException {

Python 多執行緒C段掃描、檢測 Ping掃描指令碼的實現

我就廢話不多說了，大家還是直接看程式碼吧~ import subprocess as p import time import threading

面試題精選:兩個執行緒按順序交替輸出1-100

陸陸續續，各個公司的校招季都開始了，我也成為了我司的校招面試官，最近也面了不少同學了，面試過程中也發現了很多問題，即有面試者的、也有面試官的、更有自己的問題，這裡先挖個坑，後續寫個部落格詳細聊聊，感興

試試，阿里P7的筆試題：多執行緒按序列印如何實現？

下面是阿里 P7 的一道筆試題，公眾號【Java鬥帝】內回覆666有免費電子書贈送

Java多執行緒 以7種方式讓主執行緒等待子執行緒結束

技術標籤：java 個人站：https://www.yuansu.space 一、while迴圈 對於“主執行緒如何獲取子執行緒總執行時間”的問題，最開始想到的是使用while迴圈進行輪詢：