利用Condition实现多线程交替执行

最新推荐文章于 2023-02-01 14:05:52 发布
最新推荐文章于 2023-02-01 14:05:52 发布
阅读量198 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/geekdc/p/10298464.html
版权

一、需求

  • A、B、C 三个线程，循环10次，打印出自己的名称，ABC,ABC,ABC...
  • A、B、C 三个线程，循环10次，打印出自己的名称，A一次，B三次，C五次，ABBBCCCCC，ABBBCCCCC

1.1、循环打印ABC

package com.example.demo.juc;

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

/**
 * @author DUCHONG
 * @since 2019-01-21 10:46
 **/
public class ABC {

    public static void main(String[] args) {

        PrintDemo pd=new PrintDemo();
        //A 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printA(i);
                }
            }
        },"A").start();

        //B 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printB(i);
                }
            }
        },"B").start();

        //C 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printC(i);
                }
            }
        },"C").start();
    }
}


class PrintDemo{

    Lock lock =new ReentrantLock();

    private Condition conditionA=lock.newCondition();
    private Condition conditionB=lock.newCondition();
    private Condition conditionC=lock.newCondition();

    //哪个线程等待与否的标记,flag的值：
    // 1 线程A打印，否则等待，同时将标记设置为2，唤醒线程B
    // 2 线程B打印，否则等待，同时将标记设置为3，唤醒线程C
    // 3 线程C打印，否则等待，同时将标记设置为1，唤醒线程A  外层一次循环结束。
    private Integer flag=1;
    //打印A
    public void printA(int loop){
        try{
            lock.lock();
            if(flag!=1){
                conditionA.await();
            }

            for (int i=1;i<=1;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }
            flag=2;
            conditionB.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }
    //打印B
    public void printB(int loop){
        try{
            lock.lock();
            if(flag!=2){
                conditionB.await();
            }

            for (int i=1;i<=1;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }

            flag=3;
            conditionC.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }
    //打印C
    public void printC(int loop){
        try{
            lock.lock();
            if(flag!=3){
                conditionC.await();
            }

            for (int i=1;i<=1;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }
            flag=1;
            conditionA.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }

}

结果：

1.2、循环打印ABBBCCCC

package com.example.demo.juc;

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

/**
 * @author DUCHONG
 * @since 2019-01-21 14:15
 **/
public class ABBB {

    public static void main(String[] args) {
        PrintABBBDemo pd=new PrintABBBDemo();
        //A 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printA(i);
                }
            }
        },"A").start();

        //B 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printB(i);
                }
            }
        },"B").start();

        //C 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    pd.printC(i);
                }
            }
        },"C").start();
    }

}

class PrintABBBDemo{

    Lock lock =new ReentrantLock();

    private Condition conditionA=lock.newCondition();
    private Condition conditionB=lock.newCondition();
    private Condition conditionC=lock.newCondition();

    //哪个线程等待与否的标记,flag的值：
    // 1 线程A打印，否则等待，同时将标记设置为2，唤醒线程B
    // 2 线程B打印，否则等待，同时将标记设置为3，唤醒线程C
    // 3 线程C打印，否则等待，同时将标记设置为1，唤醒线程A  外层一次循环结束。
    private Integer flag=1;
    //打印A
    public void printA(int loop){
        try{
            lock.lock();
            if(flag!=1){
                conditionA.await();
            }

            for (int i=1;i<=1;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }
            flag=2;
            conditionB.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }
    //打印B
    public void printB(int loop){
        try{
            lock.lock();
            if(flag!=2){
                conditionB.await();
            }

            for (int i=1;i<=3;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }

            flag=3;
            conditionC.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }
    //打印C
    public void printC(int loop){
        try{
            lock.lock();
            if(flag!=3){
                conditionC.await();
            }

            for (int i=1;i<=5;i++) {
                System.out.println(Thread.currentThread().getName() + "---" + loop);
            }
            flag=1;
            conditionA.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }

    }

}

结果：

 

转载于:https://www.cnblogs.com/geekdc/p/10298464.html

weixin_33860737
关注
多线程之condition使用
qq_27581753的博客
05-26 533
1.使用Condition实现等待/通知：错误用法与解决 关键字synchronized与wait()和notify()、notifyAll()方法相结合可以实现等待/通知模式，类ReetrantLock也可以实现同样的功能，但需要借助于Condition对象。Condition类是在JDK5中出现的技术，使用它有更好的灵活性，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(即对象监控器)示例，线程对象可以注册在指定的Condition中，从而可以
多线程轮流交替执行三种实现方法
沐雨金鳞
07-01 4132
第一种方法：采用公平锁实现 思路及其简单： A线程拿到锁，执行代码 B线程拿到锁，执行代码 A线程拿到锁，执行代码 ...... public class FairLockDemo { public static void main(String[] args) { Runnable target = new Runnable(){ int i = 10; // 利用公平锁 private R
Condition线程通信，交替执行
风子的博客
09-08 252
一、线程通信，交替执行 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。 *如：ABCABCABC…… 依次递归 使用锁加上condition来实现 congdition接口下的基本方法 await() //进入等待 await(long, TimeUnit)//等待时间 awaitN...
使用Condition实现多线程之间调用
u011277123的博客
11-24 1170
达人科技 2016-11-23 15:40 一，object 类的wait，notify和notifyAll Java 线程类也是一个object 类，它的实例都继承自java.lang.Thread 或其子类。wait，notify和notifyAll是Object类中的方法,常用于线程之间调度。 线程无数据运行可调用wait让线程等待，不占用CUP资源，提高CPU有效的利用率。例
多线程之Condition
03-14 148
多线程之Condition我们这说Condition,多线程编程中使用Condition对象代替lock, 能够实现在某个事件触发后才处理数据。 Condition版的生产者与消费者模式：Lock版本的生产者与消费者模式可以正常的运行。但是存在一个不足，在消费者中，总是通过while True死循环并且上锁的方式去判断钱够不够。上锁是一个很耗费CPU资源的行为。因此这种方式不是最好的。...
使用 Condition 实现多线程的生产者消费者场景
crazy的博客
02-14 380
import java.util.LinkedList; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; import java.util.stream.IntStream; import static java.lang.Thread.currentThread; import sta...
Python threading.Condition 实现线程交替打印
"Python使用`threading.Condition`交替打印两个字符的示例程序，展示了如何在多线程环境中实现线程间的同步与协作。" 在Python的多线程编程中，有时我们需要确保某些任务按特定顺序执行或者在特定条件下进行。`...
线程依次交替执行解决办法
feinifi的博客
06-29 1783
在面试题中，我们经常会遇到这样的题目，线程依次交替执行，比如有三个线程，第一个线程打印1-2-3,第二个线程接着打印4-5-6，第三个线程打印7-8-9，再更换到线程一运行打印10-11-12，依此类推。或者只有两个线程，他们直接交替执行。 我们知道，默认情况下，多线程运行，资源是共享的，也就是说他们是竞争关系，谁得到cpu资源，谁就运行，其他线程等待，当运行完毕，接下来由谁运行，是不确定的，有...
C实现循环缓冲区，线程交替执行，进行数据读取
最新发布
05-09
循环缓冲区（Circular Buffer）是一种在内存中实现的数据结构，常用于多线程环境下的数据共享，特别是当...例如，`Test_CirBuf`这个示例可能就是一个包含具体实现循环缓冲区和线程交替执行的代码，供开发者参考学习。
【java多线程】代码实现ABC三个线程，依次交替执行，ReentrantLock方式
zsq的博客
03-26 674
ABC三个线程，依次交替执行 package com.test.lock.abc; import java.util.concurrent.CountDownLatch; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; /** * 三个线程，按顺序打印ABC */ public class App { public static final Reent
java 之 三个线程交替执行任务
ETHAN IN IT
03-22 5320
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Condition实现线程间通信 * @author ETHAN * */ public class Thre
Reentrantlock condition实现线程交替执行
qq_36079526的博客
10-10 281
需求:两个线程t1、t2，执行顺序为t1-1,t2-1,t1-2,t2-2,t1-3,t2-3,…。 思路：分别为两个线程创建各自的condition，当线程任务完成时，通知对方线程获取锁，并释放锁。 public class DoubleEntranteLock { static ReentrantLock lock = new ReentrantLock(); public Lock getLock() { return lock; } static Condition condition1
condition-交替打印demo
weixin_39690861的博客
03-10 308
启动3个线程，交替打印出线程名，轮训5轮 public static void main(String[] args) { Jiaoti2 jiaoti2 = new Jiaoti2(); new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 5; i++...
利用Condition来实现多线程交替打印ABC
WhiteBear的博客
08-22 1868
使用重入锁 ReentrantLock先来获得,.newCondition对象，Condition 可以用来指定队列，唤醒指定队列中的线程，这样在多线程环境下会有更高的效率； package morning; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import j...
Java利用Condition控制线程通信完成线程按序交替
weixin_44256581的博客
08-22 187
一、Condition控制线程通信 Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。 在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。 Co
Java使用volatile或Condition实现多线程按序交替打印
弹弹霹雳的博客
11-22 536
通过volatile或Condition来实现多线程按序交替打印的代码
使用ReentrantLock的Condition交替输出数组中元素的方法 && 指定执行顺序
weixin_44887276的博客
09-09 397
ReentranLock配合Condition交替输出
JAVA 老掉牙的面试问题 线程交替打印问题，分析实操一下
默默不代表沉默
02-01 3955
java 面试， 线程交替打印
Java并发-交替打印的四种方法。
abc123mma的博客
12-02 3682
Java并发-交替打印的四种方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值