【手撕代码】多个线程交替打印

桃扇骨 2022-02-16 00:39 181阅读 0赞

### **目  录：** ###

**方法一：锁实现【推荐】**

**方法二：信号量 semaphore 实现【推荐】**

**方法三：wait / notify 实现**

**方法四：使用 Lock / Condition 实现**

--------------------

面试的过程中，多个线程交替打印是经常被要求手写的。借用本文列出几种常用的解题方法。

## 方法一：锁实现【推荐】 ##

> times：保证每个线程的打印次数；
> 
> state：保证每个线程之间的交替打印；
> 
> lock：保证每次只有一个线程能够获取到资源。

public class PrintABCUsingLock {
    
        private int times;   // 控制打印次数
        private int state;   // 当前状态值：保证三个线程之间交替打印
        private Lock lock = new ReentrantLock();   // 保证每次只有一个线程能够拿到资源
    
        public PrintABCUsingLock(int times){
            this.times = times;
        }
        
        public void printA(){
            print("A", 0);
        }
    
        public void printB(){
            print("B", 1);
        }
    
        public void printC(){
            print("C", 2);
        }
    
        private void print(String name, int targetState){
            for(int i = 0; i < times;){
                lock.lock();
                // 控制交替打印
                if(state % 3 == targetState){
                    state++;
                    i++;
                    System.out.println("线程：" + name + "，第 " + i + " 打印");
                }
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
            PrintABCUsingLock printABC = new PrintABCUsingLock(10);
            new Thread(printABC::printA).start();
            new Thread(printABC::printB).start();
            new Thread(printABC::printC).start();
        }
    }

--------------------

## 方法二：信号量 semaphore 实现【推荐】 ##

*  直接使用 semaphore 中的 state 是否为1，为1时代表可执行。

public class PrintABCUsingSemaphore {
        private int times;
        private Semaphore semaphoreA = new Semaphore(1);
        private Semaphore semaphoreB = new Semaphore(0);
        private Semaphore semaphoreC = new Semaphore(0);
    
        public PrintABCUsingSemaphore(int times){
            this.times = times;
        }
    
        public void printA() {
            try {
                print("A", semaphoreA, semaphoreB);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void printB(){
            try {
                print("B", semaphoreB, semaphoreC);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void printC(){
            try {
                print("C", semaphoreC, semaphoreA);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        private void print(String name, Semaphore current, Semaphore next) throws InterruptedException {
            for(int i = 0; i < times; i++){
                current.acquire();
                System.out.println("线程：" + name + "，第 " + i + " 打印");
                next.release();
            }
        }
    
        public static void main(String[] args) {
            PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore(10);
            new Thread(printABC::printA).start();
            new Thread(printABC::printB).start();
            new Thread(printABC::printC).start();
        }
    }

--------------------

## 方法三：wait / notify 实现 ##

*  需要使用 synchronized 保证线程安全。

public class PrintABCUsingWaitNotify {
    
        private int times;
        private int state;
        private Object objectA = new Object();
        private Object objectB = new Object();
        private Object objectC = new Object();
    
        public PrintABCUsingWaitNotify(int times){
            this.times = times;
        }
    
        public void printA(){
            try {
                print("A", 0, objectA, objectB);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void printB(){
            try {
                print("B", 1, objectB, objectC);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void printC(){
            try {
                print("C", 2, objectC, objectA);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void print(String name, int targetState, Object current, Object next) throws InterruptedException {
            for(int i = 0; i < times;){
                // 锁定当前线程
                synchronized(current){
                    while(state % 3 != targetState){
                        current.wait();
                    }
                    state++;
                    i++;
                    System.out.println("线程：" + name + "，第 " + i + " 打印");
                    synchronized(next){
                        // 通知下一个线程
                        next.notify();
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            PrintABCUsingWaitNotify printABC = new PrintABCUsingWaitNotify(10);
            new Thread(printABC::printA).start();
            new Thread(printABC::printB).start();
            new Thread(printABC::printC).start();
        }
    }

--------------------

## 方法四：使用 Lock / Condition 实现 ##

public class PrintABCUsingLockCondition {
    
        private int times;
        private int state;
        private Lock lock = new ReentrantLock();
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();
        private Condition conditionC = lock.newCondition();
    
        public PrintABCUsingLockCondition(int times){
            this.times = times;
        }
    
        public void printA(){
            print("A", 0, conditionA, conditionB);
        }
    
        public void printB(){
            print("B", 1, conditionB, conditionC);
        }
    
        public void printC(){
            print("C", 2, conditionC, conditionA);
        }
    
        private void print(String name, int targetState, Condition current, Condition next){
            for(int i = 0; i < times;){
                lock.lock();
                try {
                    while(state % 3 != targetState) {
                        // 当前线程等待
                        current.await();
                    }
                    state++;
                    i++;
                    System.out.println("线程：" + name + "，第 " + i + " 打印");
                    // 通知下一个
                    next.signal();
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        }
    
        public static void main(String[] args) {
            PrintABCUsingLockCondition printABC = new PrintABCUsingLockCondition(10);
            new Thread(printABC::printA).start();
            new Thread(printABC::printB).start();
            new Thread(printABC::printC).start();
        }
    }