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

kkoneone112023-08-31 22:26

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

synchronized + wait/notifyAll

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

java 复制代码 
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();
            }
        }
    }
}

ReetrantLock + await/signalAll

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

1.synchronized 替换为ReentrantLock

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

3.wait替换成await

4.notifyAll 替换为 signalAll

java 复制代码 
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方法唤醒下一个线程；

java 复制代码 
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，这样可以单独唤醒和等待。

Condition是什么

概念：

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

方法：

Condition依赖于Lock接口

|---------------------|------------------------|
| 方法 | 解释 |
| lock.newCondition() | 生成一个Condition |
| await() | 对应Object的wait()；使线程等待 |
| signal() | 对应Object的notify()；唤醒线程 |

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

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

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

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

相关推荐
侠客行03172 小时前
Mybatis入门到精通 一
java·mybatis·源码阅读
消失的旧时光-19433 小时前
微服务的本质，其实是操作系统设计思想
java·大数据·微服务
Coder_Boy_3 小时前
基于SpringAI的智能平台基座开发-（四）
java·人工智能·spring boot·langchain·springai
Bruce_Liuxiaowei3 小时前
Nmap+Fofa 一体化信息搜集工具打造
运维·开发语言·网络·网络安全
智航GIS3 小时前
5.1 if语句基础
开发语言·python
bu_shuo3 小时前
MATLAB中的转置操作及其必要性
开发语言·算法·matlab
码界奇点3 小时前
基于Spring Boot的内容管理系统框架设计与实现
java·spring boot·后端·车载系统·毕业设计·源代码管理
KoalaShane3 小时前
El-slider 增加鼠标滚动滑块事件
开发语言·前端·javascript
智算菩萨3 小时前
【Python进阶】搭建AI工程：Python模块、包与版本控制
开发语言·人工智能·python
C_心欲无痕4 小时前
vue3 - watchSyncEffect同步执行的响应式副作用
开发语言·前端·javascript·vue.js·vue3
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击03电脑检测软件—图吧工具箱043D 圣诞树网页代码05Linux下V2Ray安装配置指南06UV安装并设置国内源07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08jdk21下载、安装（Windows、Linux、macOS）09Claude Code Skills 实用使用手册10Gemini3 生成的基于手势控制3D粒子圣诞树