本文介绍了Java线程间的通信，重点讨论了生产者消费者模型的实现。通过共享资源仓库，生产者在没有产品时通知消费者等待，生产后通知消费者消费；消费者在没有产品时等待，消费后通知生产者继续生产。利用Java中`Object`的`wait()`、`notify()`和`notifyAll()`方法进行线程通信，确保线程同步并避免并发问题。文中还给出了具体的代码示例，包括仓库类、生产者线程和消费者线程的实现。
线程通信，线程之间的消息传递；
多个线程在操作同一个资源，但对共享资源的操作动作不同；它们共享同一个资源，互为条件，相互依赖,相互通信让任务向前推进。
线程的同步，可以解决并发更新同一个资源，实现线程同步;但不能用来实现线程间的消息传递。
线程通信生产者和消费者和仓库是个典型模型：
生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费
消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费
线程通信：使用java中Object中提供的：
public final void wait(); 注：long timeout=0 表示线程一直等待，直到其它线程通知
public final native void wait(long timeout); 线程等待指定毫秒参数的时间
public final void wait(long timeout, int nanos); 线程等待指定毫秒、微妙的时间timeout最大等待时间,以毫秒为单位，nanos额外的时间,在纳秒范围0-999999。
public final native void notify(); 唤醒一个处于等待状态的线程
public final native void notifyAll(); 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先运行
这些方法只能在同步方法或者同步代码块中使用，否则会抛出异常。
Exception in thread "Thread-0"java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at ca.bb.ShareCached.getShareCachedData(ShareCached.java:41)//wait();
以及使用，回调方法，实现线程通信。
此处使用wait()和notify()方法实现。
此例:生产A-D个商品，放入仓库，消费生产。
仓库类：
package ca.bb.threadcommunication;
/**
* 共享资源缓存和操作类
* */
public class ShareCached {
/**产品：此处使用char字符，作为存储共享数据存储类型*/
private char cache;
//产品消费标识：线程间通信信号，true未消费(生产)，false未生产(消费)
private boolean flag = false;
/**
* 生产操作(生产者)：共享数据添加方法
* */
public synchronized void addShareCachedData(char data){
//产品未消费，则生产者(生产操作)等待
if(flag){
System.out.println("产品未消费，生产者生产操作等待");
try {
//生产者等待
wait();
} catch (InterruptedException e) {
System.out.println("Thread Interrupted Exception,"+e.getMessage());
}
}
//产品已消费，则生产者继续生产
this.cache = data;
//标记已生产
flag = true;
//通知消费者已生产
notify();
System.out.println("产品"+data+"，已生产,通知消费者消费");
}
/**
* 消费操作(消费者)：共享数据获取方法
* */
public synchronized char getShareCachedData(){
//产品未生产，则消费者(消费操作)等待
if(!flag){
System.out.println("产品未生产，消费者消费操作等待");
try {
//消费者等待
wait();
} catch (InterruptedException e) {
System.out.println("Thread Interrupted Exception,"+e.getMessage());
}
}
//标记已消费
flag = false;
//通知生产者已消费
notify();
System.out.println("产品"+this.cache+"，已消费，通知生产者生产");
//产品已生产，则消费者继续消费
return this.cache;
}
}
注：如果此处，使用synchronized方法，则内置锁(对象监视锁)为this,则不能多new不同对象，如果为多线程同步，必定多个线程共享同一个对象监视锁。
使用synchronized(obj)代码块，则1.锁使用涉及当前类对象外的其他类对象；2.锁使用静态当前类对象，确保同一个锁。
生产者线程类：
package ca.bb.threadcommunication;
/**
* 生产者线程类
* */
public class Producer extends Thread{
//共享资源缓存类对象
private ShareCached sCached;
/**
* 构造加入共享资源操作类
* */
public Producer(ShareCached shareCached){
this.sCached = shareCached;
}
/**
* 生产者生产产品，放入共享数据缓存类(仓库)
* 生产A-D类型的产品
* */
@Override
public void run() {
for(char product = 'A';product <='D';product++){
try {
sleep((int)(Math.random()*3000));
} catch (InterruptedException e) {
System.out.println("Thread Interrupted Exception,"+e.getMessage());
}
//生产产品，放入共享数据缓存类(仓库)
sCached.addShareCachedData(product);
}
}
}消费者线程类：
package ca.bb.threadcommunication;
/**
* 消费者线程类
* */
public class Consumer extends Thread{
//共享资源缓存类对象
private ShareCached sCached;
/**
* 构造加入共享资源操作类
* */
public Consumer(ShareCached sharedCached){
this.sCached = sharedCached;
}
/**
* 消费者消费产品，获取共享数据缓存类(仓库)
* 消费D类型的产品停止消费
* */
@Override
public void run() {
char product = '\u0000';
do {
try {
Thread.sleep((int)(Math.random()*3000));
} catch (InterruptedException e) {
System.out.println("Consumer thread InterruptedException from run method!");
}
//消费，从仓库取走商品
product = sCached.getShareCachedData();
} while (product != 'D');
}
}线程通信测试类：
package ca.bb.threadcommunication;
public class CPTest {
public static void main(String[] args) {
//共享同一个共享资源
ShareCached shareCached = new ShareCached();
//启动消费者线程
new Consumer(shareCached).start();
//启动生产者线程
new Producer(shareCached).start();
}
}测试结果：
产品未生产，消费者消费操作等待 产品A，已生产,通知消费者消费 产品A，已消费，通知生产者生产 产品B，已生产,通知消费者消费 产品未消费，生产者生产操作等待 产品B，已消费，通知生产者生产 产品C，已生产,通知消费者消费 产品未消费，生产者生产操作等待 产品C，已消费，通知生产者生产 产品D，已生产,通知消费者消费 产品D，已消费，通知生产者生产
120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
