线程理解：三个线程交替顺序打印ABC

最新推荐文章于 2024-08-15 18:24:34 发布
最新推荐文章于 2024-08-15 18:24:34 发布
阅读量2.3k 收藏 9
点赞数 1
分类专栏： 线程 文章标签： 多线程 java thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jike11231/article/details/118303660
版权

一、题目描述

建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印
这里参照网上方案，特此整理如下：
1、使用synchronized， wait和notifyAll
2、使用Lock->ReentrantLock 和 state标志
3、使用Lock->ReentrantLock 和Condition（await 、signal、signalAll）
4、使用AtomicInteger

二、synchronized，wait和notifyAll方式

/**
 * @author 60055558
 * @version 1.0
 */
public class ThreadPrinter01 {
    /*使用同步代码块synchronized、wait、notifyAll控制线程执行顺序
    */
    public static void main(String[] args)  throws Exception{
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ThreadPrinter pa = new ThreadPrinter("A",c,a);
        ThreadPrinter pb = new ThreadPrinter("B",a,b);
        ThreadPrinter pc = new ThreadPrinter("C",b,c);

        new Thread(pa).start();
        Thread.sleep(10);// 保证初始ABC的启动顺序
        new Thread(pb).start();
        Thread.sleep(10);
        new Thread(pc).start();
        Thread.sleep(10);
    }

    public static class ThreadPrinter implements Runnable{
        private String name;//线程名称
        private Object prev;//前一个线程
        private Object self;//当前线程

        private ThreadPrinter(String name,Object prev,Object self){
            this.name = name;
            this.prev = prev;
            this.self = self;
        }

        public void run() {
            int count = 9;
            while (count > 0){ //多线程并发，不能用if，必须使用while循环
                synchronized (prev){ //先获取prev锁
                    synchronized (self){ //再获取self锁
                        System.out.print(name);
                        count --;
                        self.notifyAll(); //self锁执行完，唤醒其他线程竞争self锁，，注意此时self锁并未立即释放。
                                          //notifyAll()方法（唤醒所有 wait 线程）
                                          //notify()方法（只随机唤醒一个 wait 线程）
                    }
                    // 此时执行完self的同步块，这时self锁才释放。
                    try{
                       if(count == 0){ //代表最后一次打印，则唤醒所有prev进程，释放prev对象锁
                           prev.notifyAll();
                       } else{
                           prev.wait(); // 立即释放 prev锁，当前线程休眠，等待唤醒
                       }
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }

                }
            }
        }
    }

}

三、Lock->ReentrantLock 和 state标志

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 60055558
 * @version 1.0
 */
public class ThreadPrinter02 {
    private static Lock lock = new ReentrantLock();
    private static int state = 0;//通过state的值来确定是哪个线程打印
    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }

    //public static class ThreadPrinter implements Runnable{}
    public static  class ThreadA extends Thread {
       public void run(){
           for (int i=0;i<10;){
               try{
                   lock.lock();
                   while (state%3 == 0){// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                       System.out.print("A");
                       state ++;
                       i ++ ;
                   }
               }finally{
                   lock.unlock();
               }
           }
       }
    }

    public static  class ThreadB extends Thread {
        public void run(){
            for (int i=0;i<10;){
                try{
                    lock.lock();
                    while (state%3 == 1){
                        System.out.print("B");
                        state ++;
                        i ++ ;
                    }
                }finally{
                    lock.unlock();
                }
            }
        }
    }

    public static  class ThreadC extends Thread {
        public void run(){
            for (int i=0;i<10;){
                try{
                    lock.lock();
                    while (state%3 == 2){
                        System.out.print("C");
                        state ++;
                        i ++ ;
                    }
                }finally{
                    lock.unlock();
                }
            }
        }
    }
}

四、Lock->ReentrantLock 和Condition

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 60055558
 * @version 1.0
 */
public class ThreadPrinter03 {
    private static Lock lock = new ReentrantLock();
    private static Condition A = lock.newCondition();//Condition是被绑定到Lock上的，必须使用lock.newCondition()才能创建一个Condition
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();

    private static int count = 0;

    public static void main(String[] args) {
        new ThreadPrintA().start();
        new ThreadPrintB().start();
        new ThreadPrintC().start();
    }

    public static class ThreadPrintA extends Thread{
        public void run(){
            try{
                lock.lock();
                for(int i=0;i<10;i++){
                    while (count % 3 != 0){//注意这里是不等于0，也就是说没轮到该线程执行，之前一直等待状态
                       A.await();//该线程A将会释放lock锁，构造成节点加入等待队列并进入等待状态
                    }
                    System.out.print("A");
                    count++;
                    B.signalAll();// A执行完唤醒B线程
                }

            }catch(Exception e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
    }

    public static class ThreadPrintB extends Thread{
        public void run(){
            try{
                lock.lock();
                for(int i=0;i<10;i++){
                    while(count % 3 != 1){
                        B.await();// B释放lock锁，当前面A线程执行后会通过B.signalAll()唤醒该线程
                    }
                    System.out.print("B");
                    count ++;
                    C.signalAll();// B执行完唤醒C线程
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
    }

    public static class ThreadPrintC extends Thread{
        public void run(){
            try{
                lock.lock();
                for(int i=0;i<10;i++){
                    while(count % 3 != 2){
                        C.await();// C释放lock锁
                    }
                    System.out.print("C");
                    count ++;
                    A.signalAll();// C执行完唤醒A线程
                }
            }catch(Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
}

五、AtomicInteger

import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author 60055558
 * @version 1.0
 */
public class ThreadPrinter04 {
    private AtomicInteger ai = new AtomicInteger(0);
    private static final int MAX_SYC_VALUE = 9;

    public static void main(String[] args) {
        ThreadPrinter04 print = new ThreadPrinter04();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.MILLISECONDS, new SynchronousQueue());
        executor.execute(print.new ThreadPrintA());
        executor.execute(print.new ThreadPrintB());
        executor.execute(print.new ThreadPrintC());
        executor.shutdown();
    }

    private class ThreadPrintA implements Runnable{
        public void run() {
            while (ai.get() < MAX_SYC_VALUE){
                if(ai.get() % 3 == 0){
                    System.out.print("A");
                    ai.getAndIncrement();
                }
            }
        }
    }

    private class ThreadPrintB implements Runnable{
        public void run() {
            while (ai.get() < MAX_SYC_VALUE){
                if(ai.get() % 3 == 1){
                    System.out.print("B");
                    ai.getAndIncrement();
                }
            }
        }
    }

    private class ThreadPrintC implements Runnable{
        public void run() {
            while (ai.get() < MAX_SYC_VALUE){
                if(ai.get() % 3 == 2){
                    System.out.print("C");
                    ai.getAndIncrement();
                }
            }
        }
    }
}

参考文章
https://blog.csdn.net/hefenglian/article/details/82596072

多线程交替打印ABC的多种实现方法
想作会飞的鱼的博客
08-17 6万+
一、题目描述建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->Thre
三个线程交替打印ABC(最优算法)
qq_43281913的博客
03-16 2344
三个线程交替打印ABC的最优实现方式 看了很多关于线程交替打印ABC的，千奇百怪，有用锁的，也有用原子操作的，还有用嵌套同步代码块的，实在是很没有必要，算法题追求的是简短精炼，思想升华。算法题就是活到老学到老啦，下面就给大家介绍一个最好的算法思路。仔细看哦，不难理解。 前置知识 1.volatile关键字：多线程操作同一个变量的时候，首先获取这个变量，获取操作不存在锁，修改变量后在自己的寄存器中保存，然后提交到主内存，只有刷新到主内存，其他线程才能可见。寄存器是线程私有的，主内存是线程共享的。涉及到JV
三个线程如何交替打印ABC循环100次
最新发布
Blocking The Sky
08-15 1020
每个线程在打印字母之后，需要调用下一个Condition对象的signal方法，唤醒下一个线程。ReentrantLock可以创建多个Condition对象，每个Condition对象可以绑定一个或多个线程，实现对不同线程的精确控制。Semaphore可以创建多个信号量对象，每个信号量对象可以绑定一个或多个线程，实现对不同线程的精确控制。这是一个典型的多线程同步的问题，需要保证每个线程在打印字母之前，能够判断是否轮到自己执行，以及在打印字母之后，能够通知下一个线程执行。
每日一问 - 三个线程交替打印 ABCABC
面朝大海，春暖花开
09-24 276
每日一问 - 三个线程交替打印 ABCABC… 问题 三个线程交替打印 ABCABC.. ? 三个线程交替打印 ABCABC.. 10 次? 解决方案 三个线程交替打印 ABCABC… 创建共享资源 ： /** * wait notify 实现 ABC交替打印 */ public class ABCCoreHolder { private int counter = 0; public void printA() throws InterruptedException {
三个线程轮流打印ABC
Infor_learning的博客
07-14 7600
1、多线程if和where的区别： 就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。 2、 一.概述wait()方法可以使线程进入等待状态，而notify()可以使等待的状态唤醒 wait，notify和notifyAll方法是Object类的成员函数，所以Java的任何一个.
Java多线程——三个线程交替打印ABC
威威的博客
12-10 2871
Java多线程：三个线程交替打印ABC，线程等待唤醒机制
3个线程交替打印ABC
weixin_41758726的博客
03-20 547
package com.interview; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ABC { private static final int COUNT = 20 * 3;//20是每个字母输出20遍 private static int state = 1; // 3是有3个字母交替输出，COUN
多线程知识：三个线程如何交替打印ABC循环100次
m0_71777195的博客
07-08 3643
到此，本文内容已经讲解完毕，以上的这五种方法都可以利用不同的工具和机制来实现多线程之间的同步和通信，从而保证按照顺序交替打印ABC。这些方法各有优缺点，具体的选择需要根据实际的场景和需求来决定。
Java线程通信：三个线程交替打印1-100
渔舟的博客
09-04 5103
本文实现一个线程通信的例子：三个线程交替打印1-100。
三个线程交替顺序打印ABC
热门推荐
洞玄之境的博客
09-10 2万+
题目描述 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。 5种方法 使用synchronized, wait和notifyAll 使用Lock-&amp;gt;ReentrantLock 和 state标志 使用Lock-&amp;gt;ReentrantLock 和Con...
线程题目：三个线程循环打印100次ABC
Java慢热型混子选手
08-28 523
【代码】线程题目：三个线程循环打印100次ABC。
实现三个线程轮流执行顺序打印ABC
Bobo‘s Home
06-16 1万+
这道题目在多线程的面试题中可能遇到的比较多，由于最近一直在学习Java多线程编程的知识，这里做一个总结，总结的可能并不是很全面，有问题或者有更好的编程方法也欢迎大家指出。 这道题目的实现方式很多，这里就以我了解的进行一个总结。 首先，我们看一下题目： 有三个线程A、B、C，采用多线程的方式使三个线程轮流执行顺序打印ABC 10次，结果如下： 通过wait/notify实现 package tes...
三个线程交替打印ABC（java）
gyxx1998的博客
08-25 1066
三个线程交替打印ABC（sychronized和reentranceLock）
三个线程ABC，交替打印ABC
weixin_30765577的博客
09-03 150
转载与：https://www.cnblogs.com/x_wukong/p/4009709.html 创建3个线程，让其交替打印ABC 。 输出如下： ABCABCABCABC。 方法：使用synchronized关键字和wait() 、notify() 主要的思想就是，为了控制执行的顺序，必须要先持有a锁，也就是前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打...
三个线程交替打印ABC（C++）
qq_43287931的博客
03-07 1861
#include<iostream> #include<thread> #include<mutex> #include<condition_variable> using namespace std; mutex mtx;// 全局互斥锁. condition_variable cv;// 全局条件变量. int ready = 0;// 全局标志位. void Print_A() { unique_lock<mutex> lk(m
使用三个线程交替打印ABC
qq358660877的博客
03-29 265
【代码】使用三个线程交替打印ABC。
三个线程交替打印abc
08-26
你可以使用多线程编程来实现三个线程交替打印abc。下面是一个示例代码： ```python import threading class PrintABC: def __init__(self): self.current_letter = 'A' self.lock = threading.Lock() def print_a(self): for _ in range(10): with self.lock: while self.current_letter != 'A': self.lock.wait() print('A', end='') self.current_letter = 'B' self.lock.notify_all() def print_b(self): for _ in range(10): with self.lock: while self.current_letter != 'B': self.lock.wait() print('B', end='') self.current_letter = 'C' self.lock.notify_all() def print_c(self): for _ in range(10): with self.lock: while self.current_letter != 'C': self.lock.wait() print('C', end='') self.current_letter = 'A' self.lock.notify_all() def main(): printer = PrintABC() thread_a = threading.Thread(target=printer.print_a) thread_b = threading.Thread(target=printer.print_b) thread_c = threading.Thread(target=printer.print_c) thread_a.start() thread_b.start() thread_c.start() thread_a.join() thread_b.join() thread_c.join() if __name__ == '__main__': main() ``` 这个例子中，我们创建了一个 `PrintABC` 类，其中包含了三个方法 `print_a`、`print_b` 和 `print_c` 分别用于打印字母 'A'、'B' 和 'C'。在每个方法中，使用 `with self.lock` 来获取锁对象并进入临界区域。通过 `self.current_letter` 来确定当前应该打印的字母，并使用 `while self.current_letter != 'A'` 等待其他线程改变 `self.current_letter` 的值。当当前字母符合要求时，打印字母并切换到下一个字母，然后使用 `self.lock.notify_all()` 唤醒其他等待的线程。 在 `main` 方法中，我们创建了三个线程并分别启动它们，然后使用 `join` 方法等待所有线程执行完毕。运行这段代码时，你将会看到三个线程交替打印字母 'A'、'B' 和 'C'，每个字母连续打印十次。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值