Java Lock 中使用 await() 和 signal()实现 wait()/notify()机制

**

Java Lock 中使用 await() 和 signal()实现 wait()/notify()机制

**

案例

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

public class MyService {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void await() {
        try {
             lock.lock();
            System.out.println("await 获取锁了" + " - " + Thread.currentThread().getName());
            System.out.println("await 开始释放锁  进入 wait 状态" + " - " + Thread.currentThread().getName());
            condition.await(); // 相当于 Object().wait();
            System.out.println("await wait 结束.   获取锁继续执行" + " - " + Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("await 执行结束释放锁" + " - " + Thread.currentThread().getName());
            lock.unlock();
        }
    }

    public void signal() {
        try {
             lock.lock();
            System.out.println("signal 获取锁 " + " - " + Thread.currentThread().getName());
            condition.signal();  // 相当于 Object().notify();
            System.out.println("signal 这里通知 被await()线程继续执行       " + " - " + Thread.currentThread().getName());
            System.out.println("signal 可以看出 通知后 被await()的线程并未立即执行! 而是等到该线程 unlock()后获取锁执行"  + Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("signal 执行结束 释放锁" + " - " + Thread.currentThread().getName());
            lock.unlock();
        }
    }


}

class ThreadA extends Thread {

    private MyService myService;

    public ThreadA (MyService myService) {
        this.myService = myService;
    }

    @Override
    public  void run () {
        myService.await();
    }

}
class Run1  {

    public static void main(String[] args) throws Exception {
        MyService myService = new MyService();
        ThreadA threadA = new ThreadA(myService);
        threadA.start();
        System.out.println("这里睡眠  先让 await() 方法获取锁");
        Thread.sleep(200);
        myService.signal();
    }
}

运行结果

可以看出 Lock 中使用 await() 和 signal()实现了 wait()/notify()机制

注意 当调用 condition.signal();方法后, 当前线程并不会立即释放锁, 只有当前线程在 unlock() 后才会释放锁, 通知 wait 线程继续执行

await 获取锁了 - Thread-0
await 开始释放锁  进入 wait 状态 - Thread-0
signal 获取锁  - main
signal 这里通知 被await()线程继续执行        - main
signal 可以看出 通知后 被await()的线程并未立即执行! 而是等到该线程 unlock()后获取锁执行main
signal 执行结束 释放锁 - main
await wait 结束.   获取锁继续执行 - Thread-0
await 执行结束释放锁 - Thread-0