线程通信，线程之间的消息传递；
多个线程在操作同一个资源，但对共享资源的操作动作不同；它们共享同一个资源，互为条件，相互依赖,相互通信让任务向前推进。
线程的同步，可以解决并发更新同一个资源，实现线程同步;但不能用来实现线程间的消息传递。
线程通信生产者和消费者和仓库是个典型模型：
生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费
消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费
线程通信：使用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，已消费，通知生产者生产
