線程間通信

                                     線程間通信

 wait/notify/notify All

public class Test77 {
    public static class ThreadPrinter implements Runnable {
        private String name;
        private Object prev;
        private Object self;

        private ThreadPrinter(String name, Object prev, Object self) {
            this.name = name;
            this.prev = prev;
            this.self = self;
        }

        @Override
        public void run() {
            int count = 10;
            while (count > 0) {// 多線程併發，不能用if，必須使用whil循環
                synchronized (prev) { // 先獲取 prev 鎖
                    synchronized (self) {// 再獲取 self 鎖
                        System.out.print(name);//打印
                        count--;

                        self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時self鎖並未立即釋放。
                    }
                    //此時執行完self的同步塊，這時self鎖才釋放。
                    try {
                        prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
                    /**
                     * JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。
                     */
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ThreadPrinter pa = new ThreadPrinter("A", c, a);
        ThreadPrinter pb = new ThreadPrinter("B", a, b);
        ThreadPrinter pc = new ThreadPrinter("C", b, c);

        new Thread(pa).start();
        Thread.sleep(10);
        //保證初始ABC的啓動順序
        new Thread(pb).start();
        Thread.sleep(10);
        new Thread(pc).start();
        Thread.sleep(10);
    }
}

可以看到程序一共定義了a,b,c三個對象鎖，分別對應A、B、C三個線程。A線程最先運行，A線程按順序申請c,a對象鎖，打印操作後按順序釋放a,c對象鎖，並且通過notify操作喚醒線程B。線程B首先等待獲取A鎖，再申請B鎖，後打印B，再釋放B，A鎖，喚醒C。線程C等待B鎖，再申請C鎖，後打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什麼問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程必須按照A,B,C的順序來啓動，但是這種假設依賴於JVM中線程調度、執行的順序。

原實現存在的問題：
如果把上述代碼放到eclipse上運行，可以發現程序雖然完成了交替打印ABC十次的任務，但是打印完畢後無法自動結束線程。這是爲什麼呢？原因就在於下面這段代碼：

try {
    prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
    /**
    * JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。
    */
} catch (InterruptedException e) {
    e.printStackTrace();
}

prev.wait(); 是釋放prev鎖並休眠線程，等待喚醒。在最後一次打印完畢後，因爲count爲0，無法進入while循環的同步代碼

我們找到了了問題的原因，解決起來就簡單了。最直接的思路就是在最後一次打印操作時在不休眠線程的情況下釋放對象鎖，這可以通過notifyAll操作實現。於是改進的代碼如下

 

public static class ThreadPrinter implements Runnable {
        private String name;
        private Object prev;
        private Object self;

        private ThreadPrinter(String name, Object prev, Object self) {
            this.name = name;
            this.prev = prev;
            this.self = self;
        }

        @Override
        public void run() {
            int count = 10;
            while (count > 0) {// 多線程併發，不能用if，必須使用whil循環
                synchronized (prev) { // 先獲取 prev 鎖
                    synchronized (self) {// 再獲取 self 鎖
                        System.out.print(name);//打印
                        count--;

                        self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時self鎖並未立即釋放。
                    }
                    //此時執行完self的同步塊，這時self鎖才釋放。
                    try {
                        if (count == 0) {// 如果count==0,表示這是最後一次打印操作，通過notifyAll操作釋放對象鎖。
                            prev.notifyAll();
                        } else {
                            prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ThreadPrinter pa = new ThreadPrinter("A", c, a);
        ThreadPrinter pb = new ThreadPrinter("B", a, b);
        ThreadPrinter pc = new ThreadPrinter("C", b, c);

        new Thread(pa).start();
        Thread.sleep(10);
        //保證初始ABC的啓動順序
        new Thread(pb).start();
        Thread.sleep(10);
        new Thread(pc).start();
        Thread.sleep(10);
    }

 

ReentrantLock結合Condition

與ReentrantLock搭配的通行方式是Condition，如下：

Condition是被綁定到Lock上的，必須使用lock.newCondition()才能創建一個Condition。從上面的代碼可以看出，Synchronized能實現的通信方式，Condition都可以實現，功能類似的代碼寫在同一行中。這樣解題思路就和第一種方法基本一致，只是採用的方法不同。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ABC_Condition {
    private static Lock lock = new ReentrantLock();
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();

    private static int count = 0;

    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 0) {//注意這裏是不等於0，也就是說在count % 3爲0之前，當前線程一直阻塞狀態
                        A.await(); // A釋放lock鎖
                    }
                    System.out.print("A");
                    count++;
                    B.signal();
                    // A執行完喚醒B線程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 1) {
                        B.await();// B釋放lock鎖，當前面A線程執行後會通過B.signal()喚醒該線程
                    }
                    System.out.print("B");
                    count++;
                    C.signal();// B執行完喚醒C線程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 2) {
                        C.await();
                        // C釋放lock鎖
                    }
                    System.out.print("C");
                    count++;
                    A.signal();
                    // C執行完喚醒A線程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

Semaphore信號量方式

Semaphore又稱信號量，是操作系統中的一個概念，在Java併發編程中，信號量控制的是線程併發的數量。

public Semaphore(int permits)

其中參數permits就是允許同時運行的線程數目;
Semaphore是用來保護一個或者多個共享資源的訪問，Semaphore內部維護了一個計數器，其值爲可以訪問的共享資源的個數。一個線程要訪問共享資源，先獲得信號量，如果信號量的計數器值大於1，意味着有共享資源可以訪問，則使其計數器值減去1，再訪問共享資源。如果計數器值爲0,線程進入休眠。當某個線程使用完共享資源後，釋放信號量，並將信號量內部的計數器加1，之前進入休眠的線程將被喚醒並再次試圖獲得信號量。

Semaphore使用時需要先構建一個參數來指定共享資源的數量，Semaphore構造完成後即是獲取Semaphore、共享資源使用完畢後釋放Semaphore。

import java.util.concurrent.Semaphore;

public class ABC_Semaphore {
    // 以A開始的信號量,初始信號量數量爲1
    private static Semaphore A = new Semaphore(1);
    // B、C信號量,A完成後開始,初始信號數量爲0
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);

    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    A.acquire();
                    // A獲取信號執行,A信號量減1,當A爲0時將無法繼續獲得該信號量
                    System.out.print("A");
                    B.release();
                    // B釋放信號，B信號量加1（初始爲0），此時可以獲取B信號量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    B.acquire();
                    System.out.print("B");
                    C.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    C.acquire();
                    System.out.println("C");
                    A.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}