高频面试题：如何分别用三种姿势实现三个线程交替打印0到100

ゝ一纸荒年。 2024-03-24 23:21 11阅读 0赞

最近面试遇到的一道题，需要三个线程交替打印0-100，当时对多线程并不是很熟悉因此没怎么写出来，网上搜了之后得到现

## synchronized + wait/notifyAll ##

实现思路：判断当前打印数字和线程数的取余，不等于当前线程则处于等待状态。循环结束唤醒所有等待线程。

public class PrintExample {
        //创建一个公共锁对象
        private static final Object Lock = new Object();
        //执行线程数
        private static final int THREAD_COUNT = 3;
    
        //打印数字的起始点
        private static volatile int START = 0;
    
        //打印数字的结束点
        private static final int END = 100;
    
        private static class Print implements Runnable{
            private final int index;
    
            public Print(int index){
                this.index = index;
            }
    
    
            @Override
            public void run() {
                while(START<END){
                    synchronized (Lock){
                        //START和线程数进行取余，如果不等于当前线程的则等待
                        while(START % THREAD_COUNT != index){
                            try{
                                Lock.wait();
                            }catch (Exception e){
                                e.printStackTrace();
                            }
                        }
                        //否则进行输出
                        if(START<=END){
                            System.out.println("Thread" + (index+1) +  ",打印结果：" + START);
                        }
                        START++;
                        //唤醒等待线程
                        Lock.notifyAll();
                    }
                }
            }
    
            public static void main(String[] args) {
                for(int i = 0; i < THREAD_COUNT; i++){
                    new Thread(new Print(i)).start();
                }
            }
        }
    }

![8fa86e348ff24777b4db563e3fb26380.png][]

## ReetrantLock + await/signalAll ##

实现思路：实现方式和synchronized + wait/notifyAll儿乎完全一样。我们只需要4步：  
1.synchronized 替换为ReentrantLock

2.根据锁对象创建一个Condition对象

3.wait替换成await

4.notifyAll 替换为 signalAll

public class PrintExample {
        //创建一个公共锁对象
        private static final ReentrantLock Lock = new ReentrantLock();
    
        //根据锁对象创建一个Condition对象
        private static final Condition CONDITION = Lock.newCondition();
    
        //执行线程数
        private static final int THREAD_COUNT = 3;
    
        //打印数字的起始点
        private static volatile int START = 0;
    
        //打印数字的结束点
        private static final int END = 100;
    
        private static class Print implements Runnable{
            private final int index;
    
            public Print(int index){
                this.index = index;
            }
    
    
            @Override
            public void run() {
                while(START<END){
                    Lock.lock();
                    try {
                        //START和线程数进行取余，如果不等于当前线程的则等待
                        while(START % THREAD_COUNT != index){
                            try{
                                CONDITION.await();
                            }catch (Exception e){
                                e.printStackTrace();
                            }
                        }
                        //否则进行输出
                        if(START<=END){
                            System.out.println("Thread" + (index+1) +  ",打印结果：" + START);
                        }
                        START++;
                        //唤醒等待线程
                        CONDITION.signalAll();
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        Lock.unlock();
                    }
                    
                    }
                }
                
            public static void main(String[] args) {
                for(int i = 0; i < THREAD_COUNT; i++){
                    new Thread(new Print(i)).start();
                }
            }
        }
    }

## ReetrantLock + await/signal ##

因为Condition相对wait/notify方式，可以唤醒指定线程。那我们就完全不用每次都唤醒全部线程，仅需要唤醒下一次需要执行的线程就可以了。  
相比较 ReentrantLock + await/signalAll 改进方法：  
1.去除公共的Condition对象，替换为List<Condition> conditions；  
2.调用"下一个线程的"Condition对象的signal方法唤醒下一个线程；

public class PrintExample {
        //创建一个公共锁对象
        private static final ReentrantLock Lock = new ReentrantLock();
    
        //根据锁对象创建一个Condition对象
        //private static final Condition CONDITION = Lock.newCondition();
    
        //执行线程数
        private static final int THREAD_COUNT = 3;
    
        //打印数字的起始点
        private static volatile int START = 0;
    
        //打印数字的结束点
        private static final int END = 100;
    
        private static class Print implements Runnable{
            private final int index;
            private final List<Condition> conditions;
    
            public Print(int index,List<Condition> conditions){
                this.index = index;
                this.conditions = conditions;
            }
    
            //只唤醒下一个线程
            private void signalNext(){
                int nextIndex = (index + 1) % THREAD_COUNT;
                conditions.get(nextIndex).signal();
            }
    
            @Override
            public void run() {
                while(START<END){
                    Lock.lock();
                    try {
                        //START和线程数进行取余，如果不等于当前线程的则等待
                        while(START % THREAD_COUNT != index){
                            try{
                                conditions.get(index).await();
                            }catch (Exception e){
                                e.printStackTrace();
                            }
                        }
                        //否则进行输出
                        if(START<=END){
                            System.out.println("Thread" + (index+1) +  ",打印结果：" + START);
                        }
                        START++;
                        //唤醒等待线程
                        signalNext();
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        Lock.unlock();
                    }
    
                    }
                }
    
            public static void main(String[] args) {
                List<Condition> conditionList = new ArrayList<>();
                conditionList.add(Lock.newCondition());
                conditionList.add(Lock.newCondition());
                conditionList.add(Lock.newCondition());
                for(int i = 0; i < THREAD_COUNT; i++){
                    new Thread(new Print(i,conditionList)).start();
                }
            }
        }
    }

此处使用 List<Condition> conditions让每个线程都拥有属于自己的condition，这样可以单独唤醒和等待。

![bb21f61caaa44e49a598c898ffcbcb8e.png][]

## Condition是什么 ##

### 概念： ###

condition可以理解为条件队列。当一个线程在调用了其await方法以后，直到线程等待的某个条件为真的时候才会被唤醒。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现

### 方法： ###

Condition依赖于Lock接口

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>解释</td> 
  </tr> 
  <tr> 
   <td>lock.newCondition()</td> 
   <td>生成一个Condition</td> 
  </tr> 
  <tr> 
   <td>await()</td> 
   <td>对应Object的wait()；使线程等待</td> 
  </tr> 
  <tr> 
   <td>signal()</td> 
   <td>对应Object的notify()；唤醒线程</td> 
  </tr> 
 </tbody> 
</table>

**注意：**调用Condition的await()和signal()方法，都必须在lock.lock()和lock.unlock()之间使用

在生产者和消费者中Condition的执行方式：

*  当在线程Consumer中调用await方法后，线程Consumer将释放锁，并且将自己沉睡，等待唤醒。
 *  这时等到线程Producer获取到锁后，开始执行任务，完毕后，调用Condition的signalall方法，唤醒线程Consumer，线程Consumer恢复执行。

以上说明Condition是一个多线程间协调通信的工具类，使得某个或某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁

##  ##

[8fa86e348ff24777b4db563e3fb26380.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/ad58f9f72b7749f18f01f6c733f786c1.png
[bb21f61caaa44e49a598c898ffcbcb8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/baedc05170d04848961a0a5057c81bef.png