前言
在Java中，每个对象都可以调用 Object 的 wait/notify 方法来实现等待/通知机制。而 Condition 接口也提供了类似的方法，也能实现等待唤醒，Condition需要在ReentrantLock下使用，也就是需要上锁和释放锁，否则也会报java.lang.IllegalMonitorStateException
Condition使用
Condition方法
Condition提供await()、signal()、signalAll()方法，其中，await()是让线程等待，signal()是唤醒一个线程，signalAll()是唤醒全部线程,当前线程调用condition.await()方法后，会释放 lock 然后加入到等待队列，直到被 signal/signalAll 方法唤醒
Condition等待唤醒使用
1、await()等待唤醒
ini
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest {
public static void main(String[] args) {
final ReentrantLock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
Thread thread1 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
System.out.println(name + " <==进入条件队列等待");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
System.out.println(name + ":线程被唤醒");
}, "aa");
thread1.start();
Thread thread2 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
Thread.sleep(5000);
System.out.println(name + ":开始唤醒线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
condition.signalAll();
lock.unlock();
System.out.println(name + ":唤醒结束");
}, "通知线程");
thread2.start();
}
}输出结果为
signal()只能唤醒一个线程
ini
package cn.com.ut.july.wait;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest {
public static void main(String[] args) {
final ReentrantLock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
Thread thread1 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
System.out.println(name + " <==进入条件队列等待");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
System.out.println(name + ":线程被唤醒");
}, "aa");
thread1.start();
Thread thread3 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
System.out.println(name + " <==进入条件队列等待");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
System.out.println(name + ":线程被唤醒");
}, "aa1");
thread3.start();
Thread thread2 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
Thread.sleep(5000);
System.out.println(name + ":开始唤醒线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
condition.signal();
lock.unlock();
System.out.println(name + ":唤醒结束");
}, "通知线程");
thread2.start();
}
}输出结果为
signalAll()唤醒全部线程
ini
package cn.com.ut.july.wait;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest {
public static void main(String[] args) {
final ReentrantLock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
Thread thread1 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
System.out.println(name + " <==进入条件队列等待");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
System.out.println(name + ":线程被唤醒");
}, "aa");
thread1.start();
Thread thread3 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
System.out.println(name + " <==进入条件队列等待");
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
System.out.println(name + ":线程被唤醒");
}, "aa1");
thread3.start();
Thread thread2 = new Thread(() -> {
String name = Thread.currentThread().getName();
lock.lock();
try {
Thread.sleep(5000);
System.out.println(name + ":开始唤醒线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
condition.signalAll();
lock.unlock();
System.out.println(name + ":唤醒结束");
}, "通知线程");
thread2.start();
}
}输出结果为
Condition实现三个线程顺序输出
scss
package cn.com.ut.july.wait;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionDemo {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
new Thread(() -> {
while (true) {
try {
Thread.sleep(500);
System.out.println("A");
lock.lock();
condition2.signal();
condition1.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}).start();
Thread.sleep(100);
new Thread(() -> {
while (true) {
try {
Thread.sleep(500);
System.out.println("B");
lock.lock();
condition3.signal();
condition2.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}).start();
Thread.sleep(100);
new Thread(() -> {
while (true) {
try {
Thread.sleep(500);
System.out.println("C");
lock.lock();
condition1.signal();
condition3.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}).start();
}
}输出结果为
使用Thread.sleep()是为了保证先start()的线程先启动，以及不输出那么快
总结
Condition的await()和signal()基于Lock，相比于基于Object的wait()和notify()方法，它提供更加灵活的等待通知的机制，并且是基于AQS队列形式，但是在开发过程中，根据自己喜好选择