Java多线程之线程间协作 notify与wait的使用

（转载请注明出处：http://blog.csdn.net/buptgshengod）

1.背景

       Java多线程操作运用很广，特别是在android程序方面。线程异步协作是多线程操作的难点也是关键，也是找工作面试经常考到的地方。下面分享一下我的使用心得。

介绍几个关键字：

synchronized：线程锁，使得系统只执行当前线程。

notifyAll():唤醒其它被锁住的线程

wait():挂起线程

ExecutorService exec=Executors.newCachedThreadPool();:创建线程池

exec.execute( new Runnable() ):将线程放到线程池中管理

2.代码部分

（1）

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while(i>0) {
System.out.println("1");
i--;

try {
Thread.sleep(500);

} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
// synchronized(this){
int i = 5;
while( i > 0) {
System.out.println("2");
i--;
try {
Thread.sleep(500);

} catch (InterruptedException ie) {
}
}

}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, "t1" );
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );
t1.start();
t2.start();

}
}

我们发现，两个线程其中一个上了锁，另一个没有上锁。运行结果如下。说明了虽然一个线程上了锁，但是还是能被让其它未上锁线程访问。



（2）

当我们给两个方法都加上锁

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while(i>0) {
System.out.println("1");
i--;

try {
Thread.sleep(500);

} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
synchronized(this){
int i = 5;
while( i > 0) {
System.out.println("2");
i--;
try {
Thread.sleep(500);

} catch (InterruptedException ie) {
}
}
}

}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, "t1" );
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );
t1.start();
t2.start();

}
}运行结果变成了


先执行完第一个锁中的内容后执行第二个锁中的内容。

(3)

这时候我们使用notifyAll()和wait()

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while(i>0) {
System.out.println("1");
i--;

try {
Thread.sleep(500);
notifyAll();
wait();
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
synchronized(this){
int i = 5;
while( i > 0) {
System.out.println("2");
i--;
try {
Thread.sleep(500);
notifyAll();
wait();
} catch (InterruptedException ie) {
}
}
}

}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, "t1" );
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );
t1.start();
t2.start();

}
}

通过不断的唤醒再挂起，两个线程又交替运行。



（4）

如果想让代码更完善，可以将两个线程放到线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while(i>0) {
System.out.println("1");
i--;

try {
Thread.sleep(500);
notifyAll();
wait();
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
synchronized(this){
int i = 5;
while( i > 0) {
System.out.println("2");
i--;
try {
Thread.sleep(500);
notifyAll();
wait();
} catch (InterruptedException ie) {
}
}
}

}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
ExecutorService exec=Executors.newCachedThreadPool();
exec.execute( new Runnable() { public void run() { myt2.m4t1(); } });
exec.execute( new Runnable() { public void run() { myt2.m4t2(); } });
}
}