三个线程ABC，交替打印ABC

最新推荐文章于 2026-05-17 06:17:05 发布
原创 最新推荐文章于 2026-05-17 06:17:05 发布 · 1w 阅读 · 20 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
并发编程

当前文章被收录于：

并发编程
6 篇文章 0 人学习
订阅专栏 查看详情
本文探讨了如何使用`synchronized`、`Lock`、`Condition`和`Semaphore`实现三线程A、B、C交替打印字母。每个线程需要持有前一个线程的对象锁和自身锁，依次打印并唤醒后续线程。线程启动顺序通过延时确保，以保证正确执行顺序。

synchronized

问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC→ThreadA……循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。

主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就是前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印字母，之后首先调用self.notifyAll()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B,A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A……

为了避免JVM启动ThreadA、ThreadB、ThreadC三个线程顺序的不确定性。需要让A,B,C三个线程以确定的顺序启动，中间加一段sleep确保前一个线程已启动。

public class ABC {
    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;
        }
 
        @Override
        public void run() {
            int count = 10;
            while (count > 0) {//多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                synchronized (prev) {    // 先获取 prev 锁
                    synchronized (self) {// 再获取 self 锁
                        System.out.print(name);
                        count--;
 
                        self.notifyAll();// 先释放 self，唤醒其他线程竞争self锁
                    }
                    try {
                        prev.wait();     // 再释放 prev，休眠等待唤醒
                        /**
                         * 注意的是notify()调用后，并不是马上就释放对象锁，而是在相应的synchronized(){}语句块执行结束，自动释放锁，
                         * JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。
                         */
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
 
    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);
        new Thread(pb).start();
        Thread.sleep(10);
        new Thread(pc).start();
        Thread.sleep(10);
    }
}

Lock

public class ABC_Lock {
    private static Lock lock = new ReentrantLock();//通过JDK5中的Lock锁来保证线程的访问的互斥
    private static int state = 0;
 
    static class ThreadA extends Thread {
        @Override
        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();// lock()和unlock()操作结合try/catch使用
                }
            }
        }
    }
 
    static class ThreadB extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; ) {
                try {
                    lock.lock();
                    while (state % 3 == 1) {//多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                        System.out.print("B");
                        state++;
                        i++;
                    }
                } finally {
                    lock.unlock();// lock()和unlock()操作结合try/catch使用
                }
            }
        }
    }
 
    static class ThreadC extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; ) {
                try {
                    lock.lock();
                    while (state % 3 == 2) {//多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒
                        System.out.print("C");
                        state++;
                        i++;
                    }
                } finally {
                    lock.unlock();// lock()和unlock()操作结合try/catch使用
                }
            }
        }
    }
 
    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

Condition

public class ABC_Condition {
    private static Lock lock = new ReentrantLock();
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();
 
    private static int count = 0;
 
    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 0)
                        A.await(); // A释放lock锁
                    System.out.print("A");
                    count++;
                    B.signal(); // A执行完唤醒B线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
 
    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 1)
                        B.await();// B释放lock锁
                    System.out.print("B");
                    count++;
                    C.signal();// B执行完唤醒C线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
 
    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while (count % 3 != 2)
                        C.await();// C释放lock锁
                    System.out.println("C");
                    count++;
                    A.signal();// C执行完唤醒A线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        ThreadC threadC = new ThreadC();
        threadC.start();
        threadC.join();// main线程调用threadC.join()，会等threadC执行完成后，再执行main线程
        System.out.println(count);
    }
}

Semaphore

public class ABC_Semaphore {
    // 以A开始的信号量,初始信号量数量为1
    private static Semaphore A = new Semaphore(1);
    // B、C信号量,A完成后开始,初始信号数量为0
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);
 
    static class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    A.acquire();// A获取信号执行
                    System.out.print("A");
                    B.release();// B释放信号，B信号量为1，可以执行
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    static class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    B.acquire();
                    System.out.print("B");
                    C.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    static class ThreadC extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    C.acquire();
                    System.out.println("C");
                    A.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

三个线程交替打印ABC(最优算法)
qq_43281913的博客
03-16 2442
三个线程交替打印ABC的最优实现方式 看了很多关于线程交替打印ABC的，千奇百怪，有用锁的，也有用原子操作的，还有用嵌套同步代码块的，实在是很没有必要，算法题追求的是简短精炼，思想升华。算法题就是活到老学到老啦，下面就给大家介绍一个最好的算法思路。仔细看哦，不难理解。 前置知识 1.volatile关键字：多线程操作同一个变量的时候，首先获取这个变量，获取操作不存在锁，修改变量后在自己的寄存器中保存，然后提交到主内存，只有刷新到主内存，其他线程才能可见。寄存器是线程私有的，主内存是线程共享的。涉及到JV
从QC2.0到QC3.5：揭秘高通快充协议里那个‘会说话’的USB接口（DP/DM电压通信全解析）
最新发布
weixin_30432579的博客
05-17 185
本文深入解析高通Quick Charge（QC）快充协议中USB接口的DP/DM电压通信机制，从QC2.0到QC3.5的演进历程。通过详细解读电压协商原理、动态调压技术及安全机制，揭示快充背后的精密通信协议，帮助读者理解如何实现高效、安全的快速充电体验。
三个线程交替顺序打印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...
三个线程如何交替打印ABC循环100次
Blocking The Sky
08-15 1471
每个线程在打印字母之后，需要调用下一个Condition对象的signal方法，唤醒下一个线程。ReentrantLock可以创建多个Condition对象，每个Condition对象可以绑定一个或多个线程，实现对不同线程的精确控制。Semaphore可以创建多个信号量对象，每个信号量对象可以绑定一个或多个线程，实现对不同线程的精确控制。这是一个典型的多线程同步的问题，需要保证每个线程在打印字母之前，能够判断是否轮到自己执行，以及在打印字母之后，能够通知下一个线程执行。
多线程知识：三个线程如何交替打印ABC循环100次
m0_71777195的博客
07-08 3796
到此，本文内容已经讲解完毕，以上的这五种方法都可以利用不同的工具和机制来实现多线程之间的同步和通信，从而保证按照顺序交替打印ABC。这些方法各有优缺点，具体的选择需要根据实际的场景和需求来决定。
java多线程打印数字十次,三个线程交替打印十次ABC
weixin_34801390的博客
03-15 304
三个线程交替打印十次ABC1 package com.example.demo.thread;23 /**4 * @author wangdongjiang5 */6 public class Work {7 private volatile static String flag = "A";8 private static int countA = 0;9 priva...
线程理解：三个线程交替顺序打印ABC
jike11231的博客
06-28 2447
一、题目描述 建立三个线程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、使用AtomicI
Java多线程——三个线程交替打印ABC
威威的博客
12-10 2964
Java多线程：三个线程交替打印ABC，线程等待唤醒机制
三个线程交替打印ABC如何实现？
qq_64270799的博客
08-20 523
Java面试题
三个线程交替打印ABC
清风不请自来，只为一亲芳泽
06-01 307
三个线程交替打印ABC，分别采用信号量和加锁的方式来实现。
三个线程交替打印 ABC
小小程序员
05-13 252
【代码】三个线程交替打印 ABC。
三个线程交替打印ABC100次问题思考
Wayn111的博客
08-19 705
线程B和线程C中任意一个线程拿到锁都需要等待条件成立，线程C依赖线程B，而线程B依赖线程A，所以他们会一直阻塞直至线程A执行。条件，很容易能实现三个线程之间的交替打印，需要注意的一点就是线程A是需要第一个执行，可以看到代码里。上诉两个方法中，核心问题就是如何实现线程间的条件唤醒，如方法一，我们可以自定义。的初始状态是0，对应线程A，所以第一次打印字母也一定是A。至此，三个线程交替打印ABC100次的实现方法介绍完毕。状态变量来与各个线程绑定，每个线程都有自己对应的。,进行线程间的条件唤醒，...
C++三个线程交替打印ABC
不算太晚
08-30 2187
使用C++11的标准线程语法，用一个int变量控制条件变量的wait()阻塞等待时机，用notify_all()唤醒条件变量。 #include <iostream> #include <thread> #include <condition_variable> std::mutex mtx; std::condition_variable cv; int ready = 0; void PrintString_1() { std::unique_lock
[C++]三个线程交替打印ABC
qq_41221520的博客
09-17 740
#include<iostream> #include<thread> #include<mutex> #include<condition_variable> using namespace std; mutex mymutex; condition_variable cv; int flag=0; void printa(){ unique_lock<mutex> lk(mymutex); int count=0;
建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC
04-15 2819
建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC
三个线程交替打印ABC10次
chenjianhuideyueding的博客
05-01 596
三个线程交替打印ABC，用到线程的通知机制：用一个共享变量来表示当前需要打印的线程 index 0打印A,然后将index修改为1，然后打印B,将index修改为2，打印C,然后将index修改为0 判断等待，业务处理（就是打印和修改index）,唤醒等待 package cn.yishijie; /** * 交替打印AB 10次 */ public class ThreadNoti...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值