一、什么时候需要通信
- 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
- 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
二、怎么通信
- 如果希望线程等待, 就调用wait()
- 如果希望唤醒等待的线程, 就调用notify();
- 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
package com.soar.thread;
import java.util.TimerTask;
public class Demo4_Notify {
/*
* 等待唤醒机制
*/
public static void main(String[] args) {
final Printer p = new Printer();
new Thread(){
public void run(){
while(true){
try {
p.print1();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run(){
while(true){
try {
p.print2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
//等待唤醒机制
class Printer {
private int flag = 1;
public void print1() throws Exception{
synchronized(this){
if(flag !=1){
this.wait(); //当前线程等待
}
System.out.print("S");
System.out.print("o");
System.out.print("a");
System.out.print("r");
System.out.println();
flag = 2;
this.notify(); //随机唤醒单个等待的线程
}
}
public void print2() throws InterruptedException{
synchronized(this){ //锁对象不能用匿名对象，因为匿名对象不是同一个对象
if(flag != 2){
this.wait();
}
System.out.print("S");
System.out.print("i");
System.out.print("r");
System.out.println();
flag = 1;
this.notify();
}
}
}Console:
Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
Soar
Sir
.........三、三个或三个以上间的线程通信
多个线程通信的问题
- notify()方法是随机唤醒一个线程
- notifyAll()方法是唤醒所有线程
- JDK5之前无法唤醒指定的一个线程
- 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
wait()，notify()，sleep()方法的注意事项：
1、在同步代码块中使用什么对象当作锁，就用什么对象去调用wait()方法
2、为什么wait()方法和notify()方法定义在Object这个类中呢？
- 因为锁对象可以是任意对象，Object是所有类的基类，所以wait()方法和notify()方法需要定义在Object这个类中
3、sleep()方法和wait()方法的区别？
- sleep方法必须传入参数，参数就是时间，时间到了自动醒来
- wait方法可以传入参数，也可以不传入参数，传入参数就是在参数的时间结束后等待，不传入参数就是直接等待
- sleep方法在同步函数或同步代码块中，不释放锁（睡着了也抱着锁睡，因为它在指定的时间会醒来）
- wait方法在同步函数或者同步代码块中，释放锁
package com.soar.thread;
public class Demo5_NotifyAll {
public static void main(String[] args) {
final Printer2 p = new Printer2();
new Thread(){
public void run(){
while(true){
try {
p.print1();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run(){
while(true){
try {
p.print2();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run(){
while(true){
try {
p.print3();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
}
}
//等待唤醒机制
class Printer2 {
private int flag = 1;
public void print1() throws Exception{
synchronized(this){
while(flag !=1){
this.wait(); //当前线程等待
}
System.out.print("S");
System.out.print("o");
System.out.print("a");
System.out.print("r");
System.out.println();
flag = 2;
//this.notify(); //随机唤醒单个等待的线程
this.notifyAll(); //唤醒所有的，谁满足条件，就谁来
}
}
public void print2() throws InterruptedException{
synchronized(this){ //锁对象不能用匿名对象，因为匿名对象不是同一个对象
while(flag != 2){
this.wait(); //线程2在此等待
}
System.out.print("S");
System.out.print("i");
System.out.print("r");
System.out.println();
flag = 3;
//this.notify();
this.notifyAll();
}
}
public void print3() throws InterruptedException{
synchronized(this){ //锁对象不能用匿名对象，因为匿名对象不是同一个对象
while(flag != 3){
this.wait(); //线程3在此等待，if语句是在哪里等待，就在哪里起来
//while循环是循环判断，每次都会判断标记
}
System.out.print("H");
System.out.print("e");
System.out.print("l");
System.out.print("l");
System.out.print("o");
System.out.println();
flag = 1;
//this.notify();
this.notifyAll();
}
}
}
四、JDK1.5新特性互斥锁替代以上代码
1、同步
使用ReentrantLock类的lock()和unlock()方法进行同步
2、通信
- 使用ReentrantLock类的newCondition()方法可以获取Condition对象
- 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
- 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
package com.soar.thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Demo6_ReentrantLock {
public static void main(String[] args) {
final Printer3 p = new Printer3();
new Thread(){
public void run(){
try {
p.print1();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
new Thread(){
public void run(){
try {
p.print2();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
new Thread(){
public void run(){
try {
p.print3();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
}
class Printer3 {
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition();
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition();
private int flag = 1;
public void print1() throws Exception{
r.lock();
if(flag !=1){
c1.await();
}
System.out.print("S");
System.out.print("o");
System.out.print("a");
System.out.print("r");
System.out.println();
flag = 2;
//this.notify(); //随机唤醒单个等待的线程
c2.signal();
r.unlock();
}
public void print2() throws InterruptedException{
r.lock();
if(flag != 2){
c2.await();
}
System.out.print("S");
System.out.print("i");
System.out.print("r");
System.out.println();
flag = 3;
//this.notify();
c3.signal();
r.unlock();
}
public void print3() throws InterruptedException{
r.lock();
if(flag != 3){
c3.await();
//while循环是循环判断，每次都会判断标记
}
System.out.print("H");
System.out.print("e");
System.out.print("l");
System.out.print("l");
System.out.print("o");
System.out.println();
flag = 1;
//this.notify();
c1.signal();
r.unlock();
}
}Console：
Soar
Sir
Hello
Soar
Sir
Hello
Soar
Sir
Hello
Soar
Sir
Hello
..........