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

最近面试遇到的一道题,需要三个线程交替打印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中的每个元素都与相应线程的序号对应,保证了每个线程都拥有自己独有的Condition对象
            for (int i = 0; i < THREAD_COUNT; i++) {
                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接口

方法解释
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方法被带调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁

  • 1
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java三个线交替打印可以使用经典的信号量机制来实现。首先,我们需要创建一个共享的信号量对象并初始化为1,用来保证三个线程的顺序执行。然后,我们创建一个打印任务类,实现Runnable接口,并重写run方法。在run方法中,我们使用信号量进行线程的控制。 具体的实现步骤如下: 1. 创建一个信号量对象,并初始化为1,用来控制线程的顺序执行。 Semaphore semaphore = new Semaphore(1); 2. 创建一个打印任务类,实现Runnable接口,并重写run方法。 class PrintTask implements Runnable { private String message; private Semaphore current; private Semaphore next; public PrintTask(String message, Semaphore current, Semaphore next) { this.message = message; this.current = current; this.next = next; } public void run() { try { for (int i = 0; i < 10; i++) { // 获取当前信号量的许可 current.acquire(); // 打印当前信息 System.out.print(message); // 释放下一个信号量的许可 next.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } } 3. 创建三个打印任务对象,并指定当前信号量和下一个信号量的顺序。 Semaphore semaphoreA = new Semaphore(1); Semaphore semaphoreB = new Semaphore(0); Semaphore semaphoreC = new Semaphore(0); Runnable printTaskA = new PrintTask("A", semaphoreA, semaphoreB); Runnable printTaskB = new PrintTask("B", semaphoreB, semaphoreC); Runnable printTaskC = new PrintTask("C", semaphoreC, semaphoreA); 4. 创建三个线程,并分别启动这三个线程。 Thread threadA = new Thread(printTaskA); Thread threadB = new Thread(printTaskB); Thread threadC = new Thread(printTaskC); threadA.start(); threadB.start(); threadC.start(); 通过上述步骤,我们创建了三个信号量和三个打印任务,实现了三个线程的交替打印。其中,Semaphore类的acquire方法用于获取一个许可,如果没有许可则阻塞,release方法用于释放一个许可。通过不同的信号量控制线程的顺序执行,从而实现线程的交替打印

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kkoneone11

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值