Java线程同步锁ReentrantLock和Condition中断等待程序前提条件满足

谁践踏了优雅 2024-02-19 20:02 34阅读 0赞

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * ReentrantLock的lock和unlock必须成对使用且把需要同步的代码块包裹起来。
     * lock-unlock包裹起来的代码块，相当于Java同步关键字synchronized。
     *
     */
    public class Main {
        public static void main(String[] args) {
            Main main = new Main();
            try {
                main.test();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        private void test() {
            ReentrantLock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
    
            task(lock, condition);
            awake(lock, condition);
        }
    
        /**
         * 正常执行的任务，但是该任务执行需要满足一定的前提条件。
         * 若前提条件不满足，将进入等待，直到条件得以满足才会继续执行。
         *
         * @param lock
         * @param condition
         */
        private void task(ReentrantLock lock, Condition condition) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
    
    
                    try {
                        System.out.println("任务运行前置条件不满足，等待满足...");
                        condition.await();
    
                        System.out.println("任务运行前置条件已满足，开始执行");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
    
                    lock.unlock();
                }
            }).start();
        }
    
    
        /**
         * 假设此处就是满足前提条件的一个子任务或者异步回调模块。
         * 当条件满足后，唤醒处于等待状态的线程。
         *
         * @param lock
         * @param condition
         */
        private void awake(ReentrantLock lock, Condition condition) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
    
    
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    System.out.println("任务前置条件准备完毕，通知任务");
                    condition.signal();
    
    
                    lock.unlock();
                }
            }).start();
        }
    }

输出：