Java多线程-线程间的通信

在Java中，线程间的通信是通过wait（），notify（），nitifyAll（）进行的。在这里要特别注意一个问题，如果当前的线程不是此对象锁的所有者，却调用该对象的notify()，notify()，wait()方法时会抛出IllegalMonitorstateException，因此一定要保证在同步的代码中调用这三个函数。下面举例说明，程序实现了两个线程轮流打印1到100之间的数。

/*
* 线程间的通信：使用wait(),notify(),notifyAll().
* 注意事项:必须在同步代码块中调用上述方法，否则可能抛IllegalMonitorstateException异常
*/

class Thread1 implements Runnable {

int count = 1;
Object obj = new Object();

@Override
public void run() {

while (true) {
//wait(),notify()的调用对象必须是当前线程所持有的锁
synchronized (obj) {
//进来的线程首先唤醒之前睡眠的线程,由于当前线程获得了obj这个对象锁,
//所以即使唤醒另外一个线程,被唤醒的线程也不会立即获得被同步代码块的执行权.
obj.notify();
if (count <= 100) {
System.out.println(Thread.currentThread().getName() + "  " + (count++));
} else {
break;
}

try {
//执行完同步的代码块之后,就将当前线程挂起,等待其他线程获得锁,然后唤醒它
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
//测试主程序
public class Test {

public static void main(String[] args) {

Thread1 thread1 = new Thread1();

Thread t1 = new Thread(thread1);
Thread t2 = new Thread(thread1);

t1.start();
t2.start();
}
}

执行结果：

Thread-0 1

Thread-1 2

Thread-0 3

Thread-1 4

Thread-0 5

Thread-1 6

Thread-0 7

Thread-1 8

Thread-0 9

Thread-1 10

…….

下面列举一个生产者与消费者的问题：

//产品
public class Product {

//线程间共享的数据资源-产品数量
static int product = 2;
//各个线程共用同一把锁
static Object obj = new Object();

}

//生产者
public class Producer extends Product implements Runnable {

public void produce(){

while(true){
//同步代码块
synchronized (obj) {
obj.notify();
product++;
System.out.println("生产者生产...还剩 "+product);
//一旦产品数量超过20，生产者线程被挂起，不再生产，等待被唤醒
if (product>=20){
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

@Override
public void run() {
produce();
}

}

//消费者
public class Consumer extends Product implements Runnable{

public void consume(){

while (true){
//同步代码块
synchronized (obj) {
obj.notify();
product--;
System.out.println("消费者消费...还剩"+product);
//一旦产品数量少于0，消费者线程被挂起，不再消费，等待被唤醒
if (product <= 0) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

@Override
public void run() {
consume();
}

}
//测试主程序
public class Test {
public static void main(String[] args) {
Producer producer = new Producer();
Consumer consumer = new Consumer();

Thread t1 = new Thread(consumer);
Thread t2 = new Thread(producer);

t1.start();
t2.start();
}

}

执行结果：

消费者消费1个…还剩2

消费者消费1个…还剩1

消费者消费1个…还剩0

生产者生产2个…还剩 2

4000
生产者生产2个…还剩 4

生产者生产2个…还剩 6

生产者生产2个…还剩 8

生产者生产2个…还剩 10

生产者生产2个…还剩 12

生产者生产2个…还剩 14

生产者生产2个…还剩 16

生产者生产2个…还剩 18

生产者生产2个…还剩 20

消费者消费1个…还剩19

消费者消费1个…还剩18

消费者消费1个…还剩17

消费者消费1个…还剩16

消费者消费1个…还剩15

消费者消费1个…还剩14

消费者消费1个…还剩13

…….