[Java多線程]ABC三個線程順序輸出的問題

大概的問題是這樣的:

有A,B,C三個線程, A線程輸出A, B線程輸出B, C線程輸出C

要求, 同時啟動三個線程, 按順序輸出ABC, 循環10次

這是一個多線程協同的問題, 本身多線程是沒有執行順序的, 順序不一定, Java在concurrent里面提供了多線程同步的支持

使用ReentrantLock來解決, 還有個state整數用來判斷輪到誰執行了

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

public class ABC {
    private static Lock lock = new ReentrantLock();//通過JDK5中的鎖來保證線程的訪問的互斥
    private static int state = 0;
    
    static class ThreadA extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                lock.lock();
                if (state % 3 == 0) {
                    System.out.print("A");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
    
    static class ThreadB extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                lock.lock();
                if (state % 3 == 1) {
                    System.out.print("B");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
    
    static class ThreadC extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10;) {
                lock.lock();
                if (state % 3 == 2) {
                    System.out.print("C");
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }
    
    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
    
}

使用lock來保證只有一個線程在輸出操作, 要保證了state不會被兩個線程同時修改, 思路簡單

還可以使用condition, condition的效率可能會更高一些, await會釋放lock鎖, condition的await和signal與object的wait和notify方法作用類似

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

public class ABC2 {
    private static Lock lock = new ReentrantLock();
    private static int count = 0;
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();
    
    static class ThreadA extends Thread {

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

        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 1)
                        B.await();
                    System.out.print("B");
                    count++;
                    C.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        
    }
    
    static class ThreadC extends Thread {

        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 2)
                        C.await();
                    System.out.println("C");
                    count++;
                    A.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        
    }
    
    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        ThreadC threadC = new ThreadC();
        threadC.start();
        threadC.join();
        System.out.println(count);
    }
}

使用信號量也可以, 這個思路最簡單, 整個代碼也比較簡潔

import java.util.concurrent.Semaphore;

public class ABC3 {
    private static Semaphore A = new Semaphore(1);
    private static Semaphore B = new Semaphore(1);
    private static Semaphore C = new Semaphore(1);
    
    static class ThreadA extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    A.acquire();
                    System.out.print("A");
                    B.release();
                }
            } 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 {
        B.acquire(); C.acquire(); // 開始只有A可以獲取, BC都不可以獲取, 保證了A最先執行
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

注意:

lock是需要lock所有者去釋放的, 即誰lock, 誰釋放, 不可以跨線程, 會報java.lang.IllegalMonitorStateException;

semaphore是沒有所有者的說法, 可以跨線程釋放和獲取.

 

這是一道java筆試題, 多線程的問題現在越來越多的出現在筆試中, 要好好學習.

水平有限, 如有錯漏, 請指針, 歡迎拍磚, 共同探討!

參考文獻:

1. 深入淺出Java Concurrency: http://www.blogjava.net/xylz/archive/2010/07/08/325587.html