Condition类的等待通知，signal，signalAll，await

最新推荐文章于 2025-01-21 17:00:00 发布

李朝辉爱吃屁

最新推荐文章于 2025-01-21 17:00:00 发布

阅读量318

点赞数 1

文章标签： java jvm idea

本文链接：https://blog.youkuaiyun.com/qq_43489947/article/details/129818060

版权

该代码示例展示了如何在Java中使用ReentrantLock和Condition来控制线程的执行顺序。程序创建了三个线程，线程1先执行，然后依次唤醒线程2和线程3进行打印，确保数字按顺序输出。线程间的同步通过await()和signal()方法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

测试场景：声明三个线程，保证线程1先执行，并按照顺序打印数字。

package com.comstar.test;

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

public class TestCondition {
    //声明全局变量LOCK
    private final static Lock lock = new ReentrantLock();
    private static int sum = 1;
    public static void main(String[] args) throws InterruptedException {
        //创建三个Condition实例
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
        Condition condition3 = lock.newCondition();
        //创建三个线程，依次打印数字
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    //先进入等待，等待主线程唤醒保证线程1先执行
                    testAwait(Thread.currentThread(),condition1);
                    testPrint(Thread.currentThread());
                    //唤醒下一个执行的线程
                    testSignal(Thread.currentThread(),condition2);
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    //先进入等待，等待主线程唤醒保证线程1先执行
                    testAwait(Thread.currentThread(),condition2);
                    testPrint(Thread.currentThread());
                    //唤醒下一个执行的线程
                    testSignal(Thread.currentThread(),condition3);
                }
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    //先进入等待，等待主线程唤醒保证线程1先执行
                    testAwait(Thread.currentThread(),condition3);
                    testPrint(Thread.currentThread());
                    //唤醒下一个执行的线程
                    testSignal(Thread.currentThread(),condition1);
                }
            }
        });
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread3.setName("线程3");
        thread1.start();
        thread2.start();
        thread3.start();
        //保证全部线程沉睡之后主线程再执行唤醒
        Thread.sleep(1000);
        //先唤醒线程1
        testSignal(Thread.currentThread(),condition1);
    }

    public static void testSignal(Thread thread, Condition condition){
        //调用signal方法需要在lock代码块中使用
        lock.lock();
        try {
            System.out.println("我是线程"+thread+"准备唤醒下一个线程。。");
            condition.signal();
        } catch (Exception e){
            throw new RuntimeException();
        }finally {
            lock.unlock();
        }
    }
    public static void testSignalAll(Thread thread, Condition condition){
        //signalAll方法需要在lock代码块中使用
        lock.lock();
        try {
            System.out.println("我是线程"+thread+"准备唤醒所有线程。。");
            condition.signalAll();
        } catch (Exception e){
            throw new RuntimeException();
        }finally {
            lock.unlock();
        }
    }
    public static void testAwait(Thread thread, Condition condition){
        //await方法需要在lock代码块中使用
        lock.lock();
        try {
            System.out.println("我是线程"+thread+"准备沉睡。。");
            condition.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
    public static void testPrint(Thread thread){
        System.out.println("我是线程"+thread+"准备打印："+sum);
        sum++;
    }
}

打印结果：

我是线程Thread[线程3,5,main]准备沉睡。。
我是线程Thread[线程1,5,main]准备沉睡。。
我是线程Thread[线程2,5,main]准备沉睡。。
我是线程Thread[main,5,main]准备唤醒下一个线程。。
我是线程Thread[线程1,5,main]准备打印：1
我是线程Thread[线程1,5,main]准备唤醒下一个线程。。
我是线程Thread[线程1,5,main]准备沉睡。。
我是线程Thread[线程2,5,main]准备打印：2
我是线程Thread[线程2,5,main]准备唤醒下一个线程。。
我是线程Thread[线程2,5,main]准备沉睡。。
我是线程Thread[线程3,5,main]准备打印：3
我是线程Thread[线程3,5,main]准备唤醒下一个线程。。
我是线程Thread[线程3,5,main]准备沉睡。。
我是线程Thread[线程1,5,main]准备打印：4
我是线程Thread[线程1,5,main]准备唤醒下一个线程。。
我是线程Thread[线程2,5,main]准备打印：5
我是线程Thread[线程2,5,main]准备唤醒下一个线程。。
我是线程Thread[线程3,5,main]准备打印：6
我是线程Thread[线程3,5,main]准备唤醒下一个线程。。

在上面代码中应注意thread1和condition1的关系，因为thread1的run方法执行时，使用的是condition1调用的await方法，所以唤醒thread1也只能用condition1调用signal方法或signalAll方法；