Object中的线程等待和Condition

使用wait()notify()的前置条件

调用wait()和notify()的线程必须是已经获取了synchronized对象锁(注意这里是对象锁不是类锁也就是说被static标记的方法是不行的)的线程。否则将会抛出java.lang.IllegalMonitorStateException

wait方法会主动让出已经获取到的synchronized锁,使得当前线程阻塞。所以如果线程没有获取到synchronized锁就调用wait()或者notify()就会报错,另外调用wait()和notify()的对象必须要和synchronized

是同一个对象。

以下四种代码都是错误的。

public class Demo2 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo2 demo = new Demo2();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });
        t1.start();
    }

    public void testa(Object lock) {
        try {
            //错误的
            this.wait();
            System.out.println("aaaaaaaaaaaaaa");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo2 demo = new Demo2();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });
        t1.start();
    }

    public void testa(Object lock) {
        try {
            //错误的
            this.notify();
            System.out.println("aaaaaaaaaaaaaa");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo2 demo = new Demo2();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });
        t1.start();
    }

    public void testa(Object lock) {
        synchronized (lock) {
            try {
                //调用wait的对象是this而synchronized当前是Object对象锁
                this.wait();
                System.out.println("aaaaaaaaaaaaaa");
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo2 demo = new Demo2();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });
        t1.start();
    }

    public void testa(Object lock) {
        synchronized (lock) {
            try {
                //synchronized使用的是Object锁而调用notify()的是this对象。
                this.notify();
                System.out.println("aaaaaaaaaaaaaa");
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }
}

wait()

调用此方法将当前线程进入阻塞状态,并且让出锁,直到另一个线程调用该对象的notify()方法或notifyAll()方法。

public class Demo1 {
    public static void main(String[] args) throws Exception {
        Demo1 demo1 = new Demo1();
        Thread t1 = new Thread(() -> {
            demo1.exc();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            demo1.exc2();
        });
        t2.start();
    }

    public synchronized void exc() {
        try {
            wait();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("aaa");
    }

    public synchronized void exc2() {
        System.out.println("bbb");
    }
}

以上代码片段t1和t2两个线程都使用的是demo1这个对象的锁。t1执行后获取到了锁,然后调用wait()后自身便处于了阻塞状态,t2线程获得了demo1对象锁并执行结束。

在这段代码中t1不会只会一直阻塞因为没有线程使用demo1的notify(),t1线程也没有被中断。

wait(long timeout)

指定的时间后线程将重新恢复就绪状态，拥有争夺锁的权力。参数单位为毫秒。

public class Demo1 {
    public static void main(String[] args) throws Exception {
        Demo1 demo1 = new Demo1();
        Thread t1 = new Thread(() -> {
            demo1.exc();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            demo1.exc2();
        });
        t2.start();
    }

    public synchronized void exc() {
        try {
            wait(3000);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("aaa");
    }

    public synchronized void exc2() {
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        System.out.println("bbb");
    }
}

以上代码片段t1线程执行后会阻塞直到3秒后将重新恢复就绪状态,但此时锁被t2获取正在执行,直到t2执行结束后释放锁,t1继续执行。

wait(long timeout,int nanos)

这个重载方法除了毫秒外还允许传递一个int类型的纳秒值,取值范围是0-999999。纳秒和毫秒的换算是1毫秒=1000000纳秒。也就是说第二个参数最多接近于1毫秒。

public class Demo1 {
    public static void main(String[] args) throws Exception {
        Demo1 demo1 = new Demo1();
        Thread t1 = new Thread(() -> {
            demo1.exc();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            demo1.exc2();
        });
        //t2.start();
    }

    public synchronized void exc() {
        try {
            System.out.println(System.currentTimeMillis());
            wait(3000,999999);
            System.out.println(System.currentTimeMillis());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("aaa");
    }

    public synchronized void exc2() {
        System.out.println("bbb");
    }
}

以上代码片段只执行了t1,t1线程在阻塞前和阻塞后的时间差大概为3016毫秒。

wait释放的哪个锁？

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        t1.start();
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
        }

        t2.start();

    }

    public synchronized void testa(Object lock) {
        System.out.println("aaaaaaaaaaaaaa1");
        synchronized (lock) {
            System.out.println("aaaaaaaaaaaaaa2");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void testb(Object lock) {
        System.out.println("bbbbbbbbbbbbbbbbbbb1");
        synchronized (lock) {
            System.out.println("bbbbbbbbbbbbbbbbbbb2");
        }
    }
}

以上代码片段testa()和testb()两个方法上有synchronized方法内部还有synchronized (lock){}。在main()中线程1执行a方法线程2执行b方法。最终的执行结果是：

aaaaaaaaaaaaaa1
aaaaaaaaaaaaaa2
bbbbbbbbbbbbbbbbbbb1

出现这个结果的原因是线程1执行a方法时先拿到this锁也就是Demo对象的锁,又拿到了lock这个锁(也就是Object这个对象的锁)然后wait()执行后释放了this锁,为什么释放的是this锁？因为wait()默认使用的对象是this。也就是this.wait();

线程2执行b方法获取了this锁,但是无法拿到lock对象锁,所以进不去代码块。

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        t1.start();
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
        }

        t2.start();

    }

    public synchronized void testa(Object lock) {
        System.out.println("aaaaaaaaaaaaaa1");
        synchronized (lock) {
            System.out.println("aaaaaaaaaaaaaa2");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void testb(Object lock) {
        System.out.println("bbbbbbbbbbbbbbbbbbb1");
        synchronized (lock) {
            System.out.println("bbbbbbbbbbbbbbbbbbb2");
        }
    }
}

将代码稍稍修改,wait()由lock对象调用。执行结果是：

aaaaaaaaaaaaaa1
aaaaaaaaaaaaaa2

结果不出意料,lock.wait()释放了lock这个对象锁。线程2执行b方法拿不到this锁第一层都进不去。

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        t1.start();
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
        }

        t2.start();

    }

    public synchronized void testa(Object lock) {
        System.out.println("aaaaaaaaaaaaaa1");
        synchronized (this) {
            System.out.println("aaaaaaaaaaaaaa2");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void testb(Object lock) {
        System.out.println("bbbbbbbbbbbbbbbbbbb1");
        synchronized (lock) {
            System.out.println("bbbbbbbbbbbbbbbbbbb2");
        }
    }
}

将a方法中synchronized代码块的锁修改为this。此时a方法中的两个锁都是this。执行wait()释放this锁。线程2执行b方法可以获取this锁,同时lock对象锁占用也可以获取所以打印结果是：

aaaaaaaaaaaaaa1
aaaaaaaaaaaaaa2
bbbbbbbbbbbbbbbbbbb1
bbbbbbbbbbbbbbbbbbb2

notify()

唤醒正在等待对象监控的单个线程。

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        Thread t3 = new Thread(() -> {
            demo.testc(lock);
        });

        t2.start();
        t1.start();
        try {
            Thread.sleep(1000);
        }catch (Exception e) {
        }    
        t3.start();
    }

    public synchronized void testa(Object lock) {
        try {
            this.wait();
            System.out.println("aaaaaaaaaaaaaa");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public synchronized void testb(Object lock) {
        try {
            this.wait();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public void testc(Object lock) {
        synchronized (this) {
            try {
                this.notify();
            } catch (Exception e) {
                System.out.println(e);
            }

        }

    }
}

以上代码片段线程1和线程2执行a,b方法。而a,b方法都调用了this.wait()也就是说t1和t2线程都是被this对象锁阻塞了。线程3调用this.notify()会唤醒t1,t2中的一个阻塞线程。

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        Thread t3 = new Thread(() -> {
            demo.testc(lock);
        });

        t2.start();
        t1.start();
        try {
            Thread.sleep(1000);
        }catch (Exception e) {
        }    
        t3.start();
    }

    public synchronized void testa(Object lock) {
        try {
            this.wait();
            System.out.println("aaaaaaaaaaaaaa");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public synchronized void testb(Object lock) {
        try {
            this.wait();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public void testc(Object lock) {
        synchronized (lock) {
            try {
                lock.notify();
            } catch (Exception e) {
                System.out.println(e);
            }

        }

    }
}

将c方法中的锁更改为lock对象,notify()方法也由lock对象调用则t1,t2两个线程都不会被唤醒。因为notify()唤醒的线程只能是被和自身同一个对象锁阻塞的线程。

另外如果c方法的synchronized是this锁而调用notify()的是其他对象则也会报错。

notifyAll()

唤醒正在等待对象监控的所有线程。

public class Demo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Demo1 demo = new Demo1();

        Thread t1 = new Thread(() -> {
            demo.testa(lock);
        });

        Thread t2 = new Thread(() -> {
            demo.testb(lock);
        });

        Thread t3 = new Thread(() -> {
            demo.testc(lock);
        });

        t2.start();
        t1.start();
        try {
            Thread.sleep(1000);
        }catch (Exception e) {
        }    
        t3.start();
    }

    public synchronized void testa(Object lock) {
        try {
            this.wait();
            System.out.println("aaaaaaaaaaaaaa");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public synchronized void testb(Object lock) {
        try {
            this.wait();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }

    public void testc(Object lock) {
        synchronized (this) {
            try {
                this.notifyAll();
            } catch (Exception e) {
                System.out.println(e);
            }

        }

    }
}

以上代码将notify()更换成了notifyAll()则t1,和t2线程都会被唤醒。

Condition

condition接口它的功能其实和Object中的wait()notify()方法的作用是一样的。wait()使线程进入阻塞状态notify()解除线程的阻塞状态它们要配合synchronized使用。

也就是说只有被synchronized锁住的代码块内才可以使用wait()和notify()。

condition接口提供了await();使用线程进入阻塞状态sigal()解除线程阻塞状态。则是配合Lock接口使用的。

Lock.newCondition()方法获取一个Condition接口的实现类。

await()signal()的前置条件

await()和signal()必须要在lock()方法后，并且调用await()signal()的Condition对象必须和lock()方法是同一组内的。也就是说一个Lock对象要和Condition对象是成对使用

的。这和wait()notify()方法必须和synchronized锁是同一个对象锁是一样的。

以下四种写法都是错误的。

public class Demo2 {

    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(()->{
            demo.a();
        });
        t1.start();
    }

    public void a() {
        try {
            condition.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

public class Demo2 {

    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(()->{
            demo.a();
        });
        t1.start();
    }

    public void a() {
        try {
            condition.signal();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

public class Demo2 {

    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    ReentrantLock lock2 = new ReentrantLock();
    Condition condition2 = lock2.newCondition();
    
    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(()->{
            demo.a();
        });
        t1.start();
    }

    public void a() {
        try {
            lock.lock();
            condition2.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

public class Demo2 {

    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    ReentrantLock lock2 = new ReentrantLock();
    Condition condition2 = lock2.newCondition();
    
    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(()->{
            demo.a();
        });
        t1.start();
    }

    public void a() {
        try {
            lock.lock();
            condition2.signal();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

await()

使当前线程阻塞直到中断或被signal()方法唤醒。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
    }

    public void a() {
        try {
            lock.lock();
            condition.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上代码执行结果是t1线程被阻塞不会执行输出,t2线程会正常结束。t1线程执行a()方法后获取lock锁然后await()会将当前线程阻塞并且释放lock锁。t2线程获取锁输出结果后释放锁,但t1线程始终无人唤醒。

await(timeout,TimeUnit)

这个重载方法给除了一个等待时间和时间单位。如果在指定时间结束后线程没有被signal()方法唤醒也没有中断则会自动被唤醒。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
    }

    public void a() {
        try {
            lock.lock();
            condition.await(3,TimeUnit.SECONDS);
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上方法t1线程阻塞后释放lock锁,t2线程获取锁在执行完毕后释放lock锁。t1线程在3秒后自动唤醒然后获取lock锁执行代码。

awaitNanos(timeout)

这个重载方法以纳秒为单位的时间单位。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
    }

    public void a() {
        try {
            lock.lock();
            condition.awaitNanos(3000000000L);
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上代码片段3000000000L纳秒也就是3秒它的执行效果和condition.await(3,TimeUnit.SECONDS)是相同的。

awaitUntil(Date)

这个重载方法接收一个Date时间,表示在指定的时间到达后自动唤醒线程。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
    }

    public void a() {
        try {
            lock.lock();
            SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date parse = sm.parse("2021-01-23 22:35:00");
            condition.awaitUntil(parse);
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上代码t2线程会在时间到达后获取锁并执行完毕。

awaitUninterruptibly()

以上4个使线程阻塞的方法如果在阻塞过程中线程被调用interrupt()则会接收到一个InterruptedException异常。而awaitUninterruptibly()阻塞方法被中断则不会接收到异常。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t1.interrupt();
    }

    public void a() {
        try {
            lock.lock();
            condition.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        t1.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t2.start();
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t1.interrupt();
    }

    public void a() {
        try {
            lock.lock();
            condition.awaitUninterruptibly();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            System.out.println("bbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上两个代码片段第一个会接收到InterruptedException异常第二个则不会。

signal

signal()唤醒一个被当前lock锁阻塞的线程。它从await()阻塞队列中获取阻塞时间最长的线程将其唤醒。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        Thread t3 = new Thread(() -> {
            demo.c();
        });
        t2.start();
        t1.start();
        
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t3.start();
    }

    public void a() {
        try {
            lock.lock();
            condition.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            condition.await();
            System.out.println("bbbbbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void c() {
        try {
            lock.lock();
            System.out.println("ccccccccccc");
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上代码片段t3线程执行后会释放阻塞队列中阻塞时间最长的线程也就是t2线程,t1线程不会被唤醒。

signalAll

signal()唤醒所有被当前lock锁阻塞的线程。

public class Demo2 {

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

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        Thread t1 = new Thread(() -> {
            demo.a();
        });
        Thread t2 = new Thread(() -> {
            demo.b();
        });
        Thread t3 = new Thread(() -> {
            demo.c();
        });
        t2.start();
        t1.start();
        
        try {
            Thread.sleep(1000 * 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        t3.start();
    }

    public void a() {
        try {
            lock.lock();
            condition.await();
            System.out.println("aaaaaaaaaaaa");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void b() {
        try {
            lock.lock();
            condition.await();
            System.out.println("bbbbbbbbbbbbbbbbb");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void c() {
        try {
            lock.lock();
            System.out.println("ccccccccccc");
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

以上代码t3线程执行后会将t2,t1线程全部唤醒。

模拟生产者消费着案例

synchronized,wait,notifyAll实现

package com.datang.bingxiang;


public class Demo3 {

    int count = 0;
    int no = 0;

    public void produce() {
        synchronized (this) {
            while (count != 0) {
                try {
                    notifyAll();
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count++;
            no++;
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在生产" + no);
        }
    }

    public void consumer() {
        synchronized (this) {
            while (count == 0) {
                try {
                    notifyAll();
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count--;
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在消费" + no);
        }
    }

    public static void main(String[] args) {
        Demo3 demo = new Demo3();
        Thread t1 = new Thread(() -> {
            while (true) {
                demo.produce();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2 = new Thread(() -> {
            while (true) {
                demo.produce();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t3 = new Thread(() -> {
            while (true) {
                demo.consumer();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t4 = new Thread(() -> {
            while (true) {
                demo.consumer();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

ReentrantLock,Condition实现

package com.datang.bingxiang;

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

public class Demo4 {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    int count = 0;
    int no = 0;

    public void produce() {
        try {
            lock.lock();
            while (count != 0) {
                try {
                    condition.signalAll();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count++;
            no++;
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在生产" + no);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }

    }

    public void consumer() {
        try {
            lock.lock();
            while (count == 0) {
                try {
                    condition.signalAll();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count--;
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在消费" + no);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Demo4 demo = new Demo4();
        Thread t1 = new Thread(() -> {
            while (true) {
                demo.produce();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2 = new Thread(() -> {
            while (true) {
                demo.produce();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t3 = new Thread(() -> {
            while (true) {
                demo.consumer();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t4 = new Thread(() -> {
            while (true) {
                demo.consumer();
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}