Condition 测试记录

最新推荐文章于 2025-08-18 22:47:43 发布

Dear.er

最新推荐文章于 2025-08-18 22:47:43 发布

阅读量193

点赞数

CC 4.0 BY-SA版权

分类专栏：多线程文章标签： java eclipse tomcat

本文链接：https://blog.youkuaiyun.com/weixin_44462664/article/details/120234511

多线程专栏收录该内容

2 篇文章

订阅专栏

本文通过四个示例展示了Java中使用ReentrantLock和Condition进行并发控制的场景，包括单线程唤醒、多线程交替执行、线程间状态协调以及多条件变量控制流程。这些示例详细解释了如何利用锁和条件变量实现复杂的线程同步策略。

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

Test01

/**
 * main开启子线程
 * main主线程休眠3S
 * ...子线程开始, 尝试获取锁
 * ...子线程获取锁成功
 * ...子线程等待
 * main尝试获取锁
 * main线程获取锁成功
 * main唤醒子线程
 * main线程锁释放
 * ...子线程等待结束（被唤醒）
 * ...子线程休眠3S
 */
public class Test01 {

    /** 锁对象 */
    private static Lock lock = new ReentrantLock();

    /** condition 对象 */
    private static Condition condition = lock.newCondition();

    /** 任务 */
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("...子线程开始, 尝试获取锁");
            lock.lock();
            try {
                System.out.println("...子线程获取锁成功");

                System.out.println("...子线程等待");
                condition.await();

                System.out.println("...子线程等待结束（被唤醒）");

                System.out.println("...子线程休眠3S");
                Thread.sleep(3000);

            } catch (Exception e) {
                System.out.println("...子线程异常");
            } finally {
                lock.unlock();
                System.out.println("...子线程锁释放");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        System.out.println("main开启子线程");
        new Thread(task).start();

        System.out.println("main主线程休眠3S");
        Thread.sleep(3000);



        System.out.println("main尝试获取锁");
        lock.lock();
        try {
            System.out.println("main线程获取锁成功");

            System.out.println("main唤醒子线程");
            condition.signal();
        } finally {
            lock.unlock();
            System.out.println("main线程锁释放");
        }

    }

}

Test02

/**
 * main开启子线程
 * main主线程休眠3S(1)
 *
 * TaskA...子线程开始, 尝试获取锁
 * TaskA...子线程获取锁成功
 * TaskA...子线程休眠3S(1)
 *
 * TaskB...子线程开始, 尝试获取锁
 * TaskA...子线程等待
 * main尝试获取锁TaskA
 * TaskB...子线程获取锁成功
 * TaskB...子线程休眠3S(1)
 *
 * TaskB...子线程等待
 * main线程获取锁成功TaskA
 * main唤醒子线程TaskA
 * main线程锁释放TaskA
 * main主线程休眠3S(2)
 *
 * TaskA...子线程等待结束（被唤醒）
 * TaskA...子线程休眠3S(2)
 */
public class Test02 {

    /** 锁对象 */
    private static ReentrantLock lock = new ReentrantLock();

    /** 两个相同锁对象的 condition 对象 */
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();

    /** 任务 */
    static class TaskA implements Runnable {
        @Override
        public void run() {
            System.out.println("TaskA...子线程开始, 尝试获取锁");
            lock.lock();
            try {
                System.out.println("TaskA...子线程获取锁成功");

                System.out.println("TaskA...子线程休眠3S(1)\n");
                Thread.sleep(3000);

                System.out.println("TaskA...子线程等待");
                conditionA.await();

                System.out.println("TaskA...子线程等待结束（被唤醒）");

                System.out.println("TaskA...子线程休眠3S(2)\n");
                Thread.sleep(3000);

            } catch (Exception e) {
                System.out.println("TaskA...子线程异常");
            } finally {
                lock.unlock();
                System.out.println("TaskA...子线程锁释放");
            }
        }
    }

    /** 任务 */
    static class TaskB implements Runnable {
        @Override
        public void run() {
            System.out.println("TaskB...子线程开始, 尝试获取锁");
            lock.lock();
            try {
                System.out.println("TaskB...子线程获取锁成功");

                System.out.println("TaskB...子线程休眠3S(1)\n");
                Thread.sleep(3000);

                System.out.println("TaskB...子线程等待");
                conditionB.await();

                System.out.println("TaskB...子线程等待结束（被唤醒）");

                System.out.println("TaskB...子线程休眠3S(2)\n");
                Thread.sleep(3000);

            } catch (Exception e) {
                System.out.println("TaskB...子线程异常");
            } finally {
                lock.unlock();
                System.out.println("TaskB...子线程锁释放");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TaskA taskA = new TaskA();
        TaskB taskB = new TaskB();
        System.out.println("main开启子线程");
        new Thread(taskA).start();
        new Thread(taskB).start();

        System.out.println("main主线程休眠3S(1)\n");
        Thread.sleep(3000);

        System.out.println("main尝试获取锁TaskA");
        lock.lock();
        try {
            System.out.println("main线程获取锁成功TaskA");

            System.out.println("main唤醒子线程TaskA");
            conditionA.signal();

        } finally {
            lock.unlock();
            System.out.println("main线程锁释放TaskA");
        }

        System.out.println("main主线程休眠3S(2)\n");
        Thread.sleep(3000);

        lock.lock();
        try {
            System.out.println("main线程获取锁成功TaskB");

            System.out.println("main唤醒子线程TaskB");
            conditionA.signal();

            System.out.println("main唤醒子线程TaskB");
            conditionB.signal();

        } finally {
            lock.unlock();
            System.out.println("main线程锁释放TaskB");
        }

    }

}

Test03

/**
 * TaskA和TaskB进行锁竞争, 初始标志位 flag = false
 * 假如TaskA获取锁成功, 此时标志位 flag = false, 打印 '---'+i, 修改 flag = true, 唤醒等待线程, 释放锁
 * TaskA和TaskB再次进行锁竞争, 此时标志位 flag = true
 * 假如TaskA再次获取锁成功, 此时标志位 flag = true, 则TaskA线程等待, 并将线程让出(未释放锁)
 * TaskB获取锁成功, 此时标志位 flag = true, 打印 '***'+i, 修改 flag = false, 唤醒等待线程, 释放锁
 */
public class Test03 {

    /** 锁对象 */
    private static ReentrantLock lock = new ReentrantLock();

    /** condition 对象 */
    private static Condition condition = lock.newCondition();

    /** 标志位 */
    private static boolean flag = true;

    /** 任务 */
    static class TaskA implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (flag) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "waiting...");
                        condition.await();
                    }
                    System.out.println(Thread.currentThread().getName() + " >> " + "---" + o);
                    flag = true;
                    condition.signal();
                } catch (Exception e) {
                    System.out.println("TaskA...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    /** 任务 */
    static class TaskB implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (! flag) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "waiting...");
                        condition.await();
                    }
                    System.out.println(Thread.currentThread().getName() + " >> " + "***" + o);
                    flag = false;
                    condition.signal();
                } catch (Exception e) {
                    System.out.println("TaskB...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TaskA taskA = new TaskA();
        TaskB taskB = new TaskB();
        new Thread(taskA).start();
        new Thread(taskB).start();
    }
}

Test04

public class Test04 {

    /** 锁对象 */
    private static ReentrantLock lock = new ReentrantLock();

    /** condition 对象 */
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();

    /** 标志位 */
    private static boolean flag = true;

    /** 任务 */
    static class TaskA implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (flag) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "---" + o);
                        flag = false;
                        conditionB.signal();
                        conditionA.await();
                    }
                } catch (Exception e) {
                    System.out.println("TaskA...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    /** 任务 */
    static class TaskB implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (! flag) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "***" + o);
                        flag = true;
                        conditionA.signal();
                        conditionB.await();
                    }
                } catch (Exception e) {
                    System.out.println("TaskB...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TaskA taskA = new TaskA();
        TaskB taskB = new TaskB();
        new Thread(taskA).start();
        new Thread(taskB).start();
    }
}

Test05

public class Test05 {

    /** 锁对象 */
    private static ReentrantLock lock = new ReentrantLock();

    /** condition 对象 */
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();

    /** 标志位 */
    private static int flag = 1;

    /** 任务 */
    static class TaskA implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (flag == 1) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "-" + flag);
                        flag = 2;
                        conditionB.signal();
                        conditionA.await();
                    }
                } catch (Exception e) {
                    System.out.println("TaskA...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    /** 任务 */
    static class TaskB implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (flag == 2) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "--" + flag);
                        flag = 3;
                        conditionC.signal();
                        conditionB.await();
                    }
                } catch (Exception e) {
                    System.out.println("TaskB...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    /** 任务 */
    static class TaskC implements Runnable {
        @Override
        public void run() {
            Stream.iterate(0, i -> i + 1).limit(50).forEach(o -> {
                lock.lock();
                try {
                    if (flag == 3) {
                        System.out.println(Thread.currentThread().getName() + " >> " + "---" + flag);
                        flag = 1;
                        conditionA.signal();
                        conditionC.await();
                    }
                } catch (Exception e) {
                    System.out.println("TaskC...线程异常" + e);
                } finally {
                    lock.unlock();
                }
            });
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TaskA taskA = new TaskA();
        TaskB taskB = new TaskB();
        TaskC taskC = new TaskC();
        new Thread(taskA).start();
        new Thread(taskB).start();
        new Thread(taskC).start();
    }
}