多线程循环打印ABC浅析

已于 2022-04-02 15:27:56 修改
阅读量2.5k 收藏 4
点赞数 3
分类专栏： 随笔 文章标签： java 后端
于 2022-04-02 15:22:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45731464/article/details/123915390
版权

多线程循环打印ABC

通过ReentrantLock、状态位来实现

public class ThreadABC2 {
    // 锁
    private static ReentrantLock lock = new ReentrantLock();
    // 状态
    private static int state = 0;
    // 计数器
    private static CountDownLatch countDownLatch = new CountDownLatch(3);
    // 线程A
    static class ThreadA extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 3; ) {

                try {
                    lock.lock();
                    while (state % 3 == 0) {
                        i++;
                        state++;
                        System.out.println("A");
                    }
                }finally {
                    lock.unlock();
                }
            }
            countDownLatch.countDown();
        }

    }
    // 线程B
    static class ThreadB extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 3; ) {

                try {
                    lock.lock();
                    while (state % 3 == 1) {
                        i++;
                        state++;
                        System.out.println("B");
                    }
                }finally {
                    lock.unlock();
                }
            }
            countDownLatch.countDown();
        }
    }
    // 线程C
    static class ThreadC extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 3; ) {

                try {
                    lock.lock();
                    while (state % 3 == 2) {
                        i++;
                        state++;
                        System.out.println("C");
                    }
                }finally {
                    lock.unlock();
                }
            }
            countDownLatch.countDown();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
        countDownLatch.await();
        System.out.println("打印耗时："+(System.currentTimeMillis()-start)+"ms");
    }
}

打印结果如下：
在这里插入图片描述
但是实际结果真的就是ThreadA先执行，其次ThreadB执行，最后是ThreadC执行吗？恐怕不是吧，毕竟线程的抢占执行并非能人为控制的，因此我们在while条件执行之后添加一条输出，如图：
在这里插入图片描述
输出结果：
在这里插入图片描述
执行耗时：
在这里插入图片描述

可以看到从输出“A”到输出“B”之间输出了n条“ThreadA”，也就说明了，当线程一旦start启动，集体哪个线程能抢占资源成功，无法确定（且与代码编写顺序无关）。我们程序控制的只是输出结果，而不是线程的执行的执行顺序。
模拟还原线程执行过程：

  1. 情景一
    (1) 假设第一次抢占成功的是线程A,线程A获得锁，此时state=0，符合state%3==0的条件，那么执行i自增（记录A的打印次数），state自增，为state = 1，并执行输出语句 System.out.println(“A”),控制台输出A，然后是执行输出语句System.out.println(“ThreadA”)，最后是线程A释放掉锁。
    (2) 进入下一轮锁的争夺，此时我们期望是线程B能抢到锁，但是（通过打印结果可以看到）实际还是ThreadA抢占到了锁，因为此时state=1，不满足while的判断条件，所以控制台只会输出ThreadA。
    (3) 直到线程B抢占成功，线程B获得锁，此时state=1，符合state%3==1的条件，那么执行i自增（记录B的打印次数），state自增，为state = 2，并执行输出语句 System.out.println(“B”),没控制台输出B，然后是执行输出语句System.out.println(“ThreadB”)，最后是线程B释放掉锁。
    (4) 进入下一轮锁争夺重复，此时我们期望是线程C能抢到锁，但是（通过打印结果可以看到）实际还是ThreadB抢占到了锁，因为此时state=2，不满足while的判断条件，所以控制台只会输出ThreadB。
    (5) 直到线程C抢占成功，线程C获得锁，此时state=2，符合state%3==2的条件，那么执行i自增（记录C的打印次数），state自增，为state = 3，并执行输出语句 System.out.println(“C”),没控制台输出C，然后是执行输出语句System.out.println(“ThreadC”)，最后是线程C释放掉锁。
    那么此时第一轮ABC的循环已经分析完成，接下来的就是重复执行步骤(1)~(5)

  2. 情景二
    (1) 假设第一次抢占成功的是线程C,线程C获得锁，此时state=0，不符合state%3==2的条件执行输出语句System.out.println(“ThreadC”)，最后是线程C释放掉锁
    (2) 进入下一轮锁的争夺，此时我们期望是线程A能抢到锁，但是（通过打印结果可以看到）实际还是ThreadC抢占到了锁，因为此时state=0，不满足while的判断条件，所以控制台只会输出ThreadC。
    (3)直到线程A抢占成功，线程A获得锁，此时state=0，符合state%3==0的条件，那么执行i自增（记录A的打印次数），state自增，为state = 1，并执行输出语句 System.out.println(“A”),没控制台输出A，然后是执行输出语句System.out.println(“ThreadA”)，最后是线程A释放掉锁。
    步骤(3)已经与情景一的情况基本一致，所有接下执行的步骤参考情景一的(2)~(5)
    至此，我们基本分析完线程的执行过程，通过这种方式我们发现，线程的执行不是很高效或者说不够“智能”，因为在执行第一遍循环ABC的时候，线程A、线程B和线程C可能都执行了很多遍，线程的每一次执行都要经历获取锁和释放锁的过程，而且线程的状态也需要发生变化，即每多执行一遍就有一次相应的开销，所以这种方式的性能开销比较大，那有什么好的优化方式呢？在下一种方法中我们引入了Condition，来控制线程

通过ReentrantLock、状态位、Conidton来实现

public class ThreadABCWithCondition {
    // 锁
    private static ReentrantLock lock = new ReentrantLock();
    // 条件
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();
    // 状态位
    private static int state = 0;
    // 计数器
    private static CountDownLatch countDownLatch = new CountDownLatch(3);

    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 3;) {
                    while (state % 3 != 0) {
                        // 当不符合该线程执行条件时
                        System.out.println("Why A");
                        conditionA.await();
                    }
                    conditionB.signal();
                    state++;
                    i++;
                    System.out.println("A");
                    //  conditionA.await();
                }


            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            countDownLatch.countDown();
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 3;) {
                    while (state % 3 != 1) {
                        // 当不符合该线程执行条件时
                        System.out.println("Why B");
                        conditionB.await();
                    }
                    conditionC.signal();
                    state++;
                    i++;
                    System.out.println("B");
					// conditionB.await();
                }


            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            countDownLatch.countDown();
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 3;) {
                    while (state % 3 != 2) {
                        // 当不符合该线程执行条件时
                        System.out.println("Why C");
                        conditionC.await();
                    }
                    conditionA.signal();
                    state++;
                    i++;
                    System.out.println("C");
					// conditionC.await();
                }


            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            countDownLatch.countDown();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        long start= System.currentTimeMillis();
        new ThreadC().start();
        new ThreadA().start();
        new ThreadB().start();
        countDownLatch.await();
        System.out.println("打印耗时："+(System.currentTimeMillis()-start)+"ms");

    }
}

输出结果：
在这里插入图片描述
通过控制台打印篇幅来看，使用Condition之后，输出打印明显减少，而且通过执行时间也可以看出，执行效率有所提升。
使用Condition后，锁竞争的过程如下：
在这里插入图片描述

模拟还原线程执行过程：
(1)首先线程C获取到了锁，此时state=0，符合while的判断条件，所以会输出“Why C”，并且执行await（），将线程C的锁释放掉，并且线程C的状态变为waiting状态并进入Condition的等待队列。
(2)进入下一轮锁竞争，此时只有线程B和线程A有获取锁的资格，若线程B获取，执行过程同过程(1),输出“Why B”，并且执行await（），将线程的B锁释放掉，并且线程B的状态变为waiting状态并进入Condition的等待队列。
(3)进入下一轮锁竞争，此时只有线程A有获取锁的资格，线程A获取锁，state=0,不会执行while里的代码，i自增，state自增，唤醒线程B，线程B进入Runnable状态，并输出“A”，紧接着会进入下一次for循环，此时state=1，会进入执行while里面的逻辑，输出“Why A”，并且将线程A进行挂起并释放持有的锁。
(4)进入下一轮锁竞争，此时只有线程B有获取锁的资格，线程B获取锁，state=1,不会执行while里的代码，i自增，state自增，唤醒线程C，线程C进入Runnable状态，并输出“B”，紧接着会进入下一次for循环，此时state=2，会进入执行while里面的逻辑，输出“Why B”，并且将线程B进行挂起并释放持有的锁。
(5)进入下一轮锁竞争，此时只有线程C有获取锁的资格，线程C获取锁，state=2,不会执行while里的代码，i自增，state自增，唤醒线程A，线程A进入Runnable状态，并输出“C”，紧接着会进入下一次for循环，此时state=3，会进入执行while里面的逻辑，输出“Why C”，并且将线程C进行挂起并释放持有的锁。
(6)继续循环步骤(3)~(5),直到完成打印

早餐加个蛋
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java多线程循环打印ABC等问题（三种方式），内含福利
m0_61068496的博客
03-30 1033
总的来说，面试是有套路的，一面基础，二面架构，三面个人。最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友存中…(img-oUlhubVd-1711751998481)]总的来说，面试是有套路的，一面基础，二面架构，三面个人。最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友[外链图片转存中…(img-32ceZtcT-1711751998482)]
三个线程轮流打印ABC
Infor_learning的博客
07-14 6893
1、多线程if和where的区别： 就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。 2、 一.概述wait()方法可以使线程进入等待状态，而notify()可以使等待的状态唤醒 wait，notify和notifyAll方法是Object类的成员函数，所以Java的任何一个.
多线程打印
最新发布
qq_52416556的博客
06-09 275
缺点：效率低，会出现浪费的竞争。比如说，一直是偶数线程拿到锁，进行判断后不满足条件，就不会去执行打印语句，然后跳出，这样的话很多次竞争拿到锁是没有意义的。线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。● 第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决 此问题。优点：效率高，一个线程拿到锁就去打印，打印完，唤醒其他线程，自己就休眠，每次的竞争都是有意义的。比如，必须先 2 后 1 打印。
Java多线程循环打印ABC的5种实现方法
XM_no_homework的博客
01-05 303
https://blog.csdn.net/weixin_39723337/article/details/80352783
使用ReentrantLock顺序打印-循环打印ABC
qq_40988139的博客
06-13 256
ReentrantLock练习代码，利用ReentrantLock完成循环打印和达到同步控制的目的，代码案例为循环打印-循环打印ABC
多线程下实现精确控制（lock、CountDownLatch、CyclicBarrier、Semaphore、ReadWriteLock）
weixin_51681634的博客
11-23 254
用 lock相较于 synchronized优点在于：可以用condition 实现对锁的精确控制 每个condition对象相当于一把锁，可以准确阻塞/ 唤醒特定线程 资源类 public class Number { int num = 1; ReentrantLock lock = new ReentrantLock(); Condition conditionA = lock.newCondition(); Condition conditionB = lock.newCondition(); .
Java多线程连续打印abc实现方法详解
08-19
Java多线程连续打印abc实现方法详解 Java多线程连续打印abc实现方法详解是 Java 编程语言中的一种常见问题，旨在解决三个线程同时执行，要求打印出10个连着的abc的难题。该问题的解决方案需要使用同步机制来确保三...
java多线程每个线程挨着打印ABC的4种实现方式
08-23
java多线程每个线程挨着打印ABC的4种实现方式，有4个线程t1、t2、t3、t4，t1打印A后t2打印A再t3打印A再t4打印A，然后从新回到t1打印B再t2打印B...t4打印B... 4个线程轮流打印abc... 一个线程可以理解为一个人，打印...
java多线程实现有序输出ABC
08-25
"java多线程实现有序输出ABC" java多线程实现有序输出ABC是java多线程编程中的一种常见问题，它的本质是控制线程的执行顺序，实现线程之间的同步和通信。在java中，可以使用多种方式来实现多线程的有序输出，以下...
iOS多线程开发——NSThread浅析
09-02
本篇文章将深入浅析NSThread在iOS多线程开发中的应用。 首先，初始化并启动一个线程是NSThread的基本操作。在`viewWillAppear:`方法中，我们可以创建一个新的线程实例，通过`initWithTarget:selector:object:`方法...
多线程与循环队列
12-30
在计算机科学中，多线程和循环队列是两个重要的概念，它们在高效并发编程中发挥着关键作用。本文将详细探讨多线程环境下的循环队列应用。 首先，我们来理解多线程。多线程是一种编程模型，允许一个程序同时执行多个...
多线程依次循环打印26个英文字母
03-03
多线程依次循环打印26个英文字母
Java用三个线程按顺序循环打印 abc 三个字母,比如 abcabcabc。(再尝试）
weixin_41704428的博客
05-29 4191
    之前的文章（点击打开链接）中解决此问题使用的同步代码块，本次使用的线程安全类来顺序输出，并还能认识到一个Java异常和抛出异常的原因。    线程安全类代码：package JavaDay5_29; /** * @author myvina@qq.com * @date 18-5-29 上午10:28 */ public class PrintLetter { priv...
面试算法题：三线程循环打印ABC
又听凌晨的钟声
04-28 3800
面试遇到三线程循环打印ABC的题目，当时没写出来，然后经过查阅，进行整理了一下。 1、题目 有A、B、C 三个线程，A线程 输出“A”，B线程 输出“B”，C线程 输出“C”，要求同时启动3个线程，按照顺序输出“ABC”，循环10次，请使用代码实现。 2、问题分析 A、B、C 三个线程；这表示我们要使用多线程同步，有人说了这不废话吗。是的，笔者只是想说，多线程的实现，有几种方式，①继承Threa...
利用多线程按顺序连续输出abc10次
jiangzuofengqiao的博客
04-20 1018
多线程无论是在面试还是在公司都是经常会出现和用到的技术。今天我通过一道小题融合多项多线程技术。 这道题是利用多线程连续输出ABC十次。首先，我先说明解决这道题的方法不唯一，而我只提供一种，其他方法希望读者自己尝试。第一步需要定义三个线程，继承Runnablej接口，重写其中方法并且加上synchronized锁，（synchronized是一种互斥同步锁，作用是在多线程程序中一次只能运行一个线程，并且同步更改），只用synchronized还不够吗，我们需要volatile关键字修饰一个变量用来控制线程执行
线程通讯之循环打印abc
zlj1217的博客
07-10 224
循环打印abc有很多方法，这里去记录一种用条件变量condition去写的一种实现方法。package communication; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock...
多线程之——实现循环打印"abc"
Jackson Zhang
10-12 1424
问题：有三个线程ID分别是A、B、C,请有多线编程实现，在屏幕上循环打印10次ABCABC… 思路：可以使用同步多线程对打印字符的控制 public class CirclePrintABC { public static void main(String args[]) { SingleInstance si = SingleInstance.newInstance(); Thre
java 多线程循环输出ABC
fengzijinliang的专栏
05-11 1184
第一：使用对象lock和unlock控制输出： import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ABC { private static int state = 0; public static void main(Strin
三个线程循环打印abc
08-24
为了实现三个线程循环打印ABC，可以使用Synchronized同步方法和Object的wait()和notify()方法。首先，创建三个线程A、B、C，并设置它们的打印次数为10。然后，通过使用三个对象锁a、b、c来控制线程的执行顺序。A线程...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值