JUC-Condition和Lock实践-线程按序交替执行

编写一个程序,开启 3 个线程,这三个线程的 ID 分别为 A、B、C,每个线程将自己的 ID 在屏幕上打印 10 遍,要求输出的结果必须按顺序显示。
如:ABCABCABC…… 依次递归

这里只使用conditon和Lock组合使用,不考虑synchronized和wait的方式:

第一种方式:使用一个condition,跟while条件组合。

通过signalAll,每次执行完唤醒所有的线程。

每个线程唤醒后,是否阻塞通过while里面的变量值来决定:

package com.atguigu.juc;

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

/*
 * 编写一个程序,开启 3 个线程,这三个线程的 ID 分别为 A、B、C,每个线程将自己的 ID 在屏幕上打印 10 遍,要求输出的结果必须按顺序显示。
 *    如:ABCABCABC…… 依次递归
 */
public class TestABCAlternate {

    public static void main(String[] args) {
        AlternateDemo ad = new AlternateDemo();

        new Thread(new Runnable() {
            @Override
            public void run() {

                //注意:各个线程的循环次数必须相等,否则当一个线程唤醒另一个Condition的时候,对应
                //唤醒锁所在的线程已经执行完了,此时就会一直等待,而其他没执行完的线程则一直阻塞。
                for (int i = 1; i <= 20; i++) {
                    ad.loopA(i);
                }

            }
        }, "A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 1; i <= 20; i++) {
                    ad.loopB(i);
                }

            }
        }, "B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 1; i <= 20; i++) {
                    ad.loopC(i);

                    System.out.println("-----------------------------------");
                }
            }
        }, "C").start();
    }
}

class AlternateDemo{

    private int number = 1; //当前正在执行线程的标记

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    /**
     * @param totalLoop : 循环第几轮
     */
    public void loopA(int totalLoop){
        lock.lock();

        try {
            //1. 判断,如果number不为1,则该线程阻塞
            while(number != 1){
                condition.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }

            //3. 修改值来决定哪个线程能够下一个执行,并且唤醒所有的线程。
            number = 2;
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void loopB(int totalLoop){
        lock.lock();
        try {
            //1. 判断
            while(number != 2){
                condition.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }
            //3. 唤醒
            number = 3;
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void loopC(int totalLoop){
        lock.lock();

        try {
            //1. 判断
            while(number != 3){
                condition.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }
            //3. 唤醒
            number = 1;
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果:

第二种方式:每个线程分配一个condition对象,与if组合。

1,通过conditionA.signal()来唤醒conditionA所wait的线程,这种方式可以指定唤醒哪个线程,以此来实现线程间通信。

所以不会出现唤醒其他错误的线程,而需要通过while循环判断的情况,只需要if即可。

2,定义一个变量的值,通过改变这个变量的值,来决定究竟当前线程是否进入等待。

例如,这里有三个线程,则需要三个condition对象,每个condition对象分别分配到不同的线程运算里面,进行await,signal等操作,

通过不同condition对象之间的相互通信,互相唤醒。

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

实现代码:

package com.atguigu.juc;

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

/*
 * 编写一个程序,开启 3 个线程,这三个线程的 ID 分别为 A、B、C,每个线程将自己的 ID 在屏幕上打印 10 遍,要求输出的结果必须按顺序显示。
 *    如:ABCABCABC…… 依次递归
 */
public class TestABCAlternate {

    public static void main(String[] args) {
        AlternateDemo ad = new AlternateDemo();

        new Thread(new Runnable() {
            @Override
            public void run() {

                //注意:各个线程的循环次数必须相等,否则当一个线程唤醒另一个Condition的时候,对应
                //唤醒锁所在的线程已经执行完了,此时就会一直等待,而其他没执行完的线程则一直阻塞。
                for (int i = 1; i <= 20; i++) {
                    ad.loopA(i);
                }

            }
        }, "A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 1; i <= 20; i++) {
                    ad.loopB(i);
                }

            }
        }, "B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 1; i <= 20; i++) {
                    ad.loopC(i);

                    System.out.println("-----------------------------------");
                }

            }
        }, "C").start();
    }

}

class AlternateDemo{

    private int number = 1; //当前正在执行线程的标记

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    /**
     * @param totalLoop : 循环第几轮
     */
    public void loopA(int totalLoop){
        lock.lock();

        try {
            //1. 判断
            if(number != 1){
                condition1.await();
            }

            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }

            //3. 修改number值,唤醒condition2的等待线程,使得condition2.await()后面的代码继续执行
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void loopB(int totalLoop){
        lock.lock();

        try {
            //1. 判断
            if(number != 2){
                condition2.await();
            }

            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }

            //3. 唤醒
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void loopC(int totalLoop){
        lock.lock();

        try {
            //1. 判断
            if(number != 3){
                condition3.await();
            }

            //2. 打印
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }

            //3. 唤醒
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

执行结果:

原文地址:https://www.cnblogs.com/alsf/p/9136577.html

时间: 2024-10-14 12:38:41

JUC-Condition和Lock实践-线程按序交替执行的相关文章

java 面试题 -- 线程 按序 交替

编写一个程序,开启 3 个线程,这三个线程的 ID 分别为A.B.C,每个线程将自己的 ID 在屏幕上打印 10 遍,要求输出的结果必须按顺序显示.如:ABCABCABC-- 依次递归? package com.company; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /

线程的2种实现和线程的交替执行

学了线程,收获不少,记录下了吧. 一.线程的主要两种实现方法. 1.继承Thread类,重写run()方法 main方法中创建子类,引用调用start()方法 实例如下: //继承Thread类,重写run()方法 public class ThreadOne extends Thread { public void run() { for (int i = 1; i <=100; i++) { System.out.println(this.getName()+":"+i);

两个线程,交替执行

import java.util.*; public class Main { static ArrayList<Integer> list=new ArrayList<Integer>(); private static Object lock=new Object(); private static int a=1; private static int b=1; static boolean bool=true; public static void main(String[

(三)juc高级特性——虚假唤醒 / Condition / 按序交替 / ReadWriteLock / 线程八锁

8. 生产者消费者案例-虚假唤醒 参考下面生产者消费者案例: /* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor pro = new Productor(clerk); Consumer cus = new Consumer(clerk); new Thread(pro, "生产

多线程按序交替打印

一.线程按序交替打印 效果展示: A 1 A 2 A 3 A 4 A 5 B 1 B 2 B 3 B 4 B 5 C 1 C 2 C 3 C 4 C 5 代码实现: package juc; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class AlternativePrint { private ReentrantLock lock =

使用Condition Variables 实现一个线程安全队列

使用Condition Variables实现一个线程安全队列 多线程代码需要面对的一个问题和是如何把数据从一个县城传到另一个县城. 举个栗子,一个常见的是把串行算法并行化方法是,把他们分成块并且做成一个管道.管道中任意一块都可以单独在一个线程里运行.每个阶段完成后添加数据到输入队列给下个阶段. Basic Thread Safety with a Mutex 使用mutex实现简单的线程安全 最简单的办法是封装一个非线程安全的队列,使用mutex保护它(实例使用boost中的方法和类型,需要1

一个线程加一运算,一个线程做减一运算,多个线程同时交替运行--synchronized

使用synchronized package com.pb.thread.demo5; /**使用synchronized * 一个线程加一运算,一个线程做减法运算,多个线程同时交替运行 * * @author Denny * */ public class Count { private int num = 0; private boolean flag = false; // 标识 //加法 public synchronized void add() { while (flag) { tr

记录一次回客科技有关线程的笔试题,三个线程加法和一个线程减法 ,延申的两个线程交替执行

今天去了回客科技 笔试了一波.很遗憾啊,脑袋有思路 但是还没到手写代码很熟练的程度,基本功不到位. 第一道:线程的题:三个线程 +1 一个线程 -1 运算 . 看到网上还有四个线程的,两个加法计算,两个减法运算.基本的思路都是一样的 ,注意看同步处理. 下面贴出代码实现: public class AddTest { private static int i; private static Object object = new Object(); public static void main

多线程交替执行

package com.xsz.demo; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /**  * 兩個線程交替執行  * @author cwqi  */ public class AdvanceMutiThread { public static void main(S