并发编程之的await和signal等方法的详细解析

await() signal() 和 signalAll()、wait() 与 await()

wait() 和 sleep() 的区别 同：

1. 都是线程同步时会用到的方法，使当前线程暂停运行，把机会交给其他线程

   2.如果任何线程在等待期间被中断都会抛出InterruptedException

   3.都是native() 方法

异：

1. wait() 是Object超类中的方法；而sleep()是线程Thread类中的方法

2. 对锁的持有不同，wait()会释放锁，而sleep()并不释放锁

3. 唤醒方法不完全相同，wait() 依靠notify或者notifyAll 、中断、达到指定时间来唤醒；而sleep()到达指定时间被唤醒.

4. 使用位置不同，wait只能在同步代码块或同步控制块中使用，而sleep可以在任何位置使用。

await() signal() 和 signalAll()

java.util.concurrent类库中提供的Condition类来实现线程之间的协调。

在Condition上调用 await() 方法使线程等待，其他线程调用signal() 或 signalAll() 方法唤醒等待的线程。

ReentrantLock里面默认有实现newCondition()方法，新建一个条件对象。

使用Lock来获取一个Condition对象，使用重入锁ReentrantLock。

wait() 与 await()

1. wait()是Object超类中的方法，而await()是ConditionObject类里面的方法.

2. await会导致当前线程被阻塞，会释放锁，这点和wait是一样的

3. await中的lock不再使用synchronized把代码同步包装起来

4. await的阻塞需要另外的一个对象condition

5. notify是用来唤醒使用wait的线程；而signal是用来唤醒await线程。

6. ==所在的超类不同使用场景也不同，wait一般用于Synchronized中，而await只能用于ReentrantLock锁中

await和signalAll案例

await和signalAll都是Condition类中的方法

• 在synchronized 中 可以使用的是wait和notify

• 而在lock同步锁中 只能使用 await 和signal

​

class Resource{
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    //number++
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while(number != 0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+":"+number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //number--
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while(number == 0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+":"+number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
​
​
}