线程通信，线程之间的消息传递；

多个线程在操作同一个资源，但对共享资源的操作动作不同；它们共享同一个资源，互为条件，相互依赖,相互通信让任务向前推进。

线程的同步，可以解决并发更新同一个资源，实现线程同步;但不能用来实现线程间的消息传递。

线程通信生产者和消费者和仓库是个典型模型：

生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费

消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费

线程通信：使用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，已消费，通知生产者生产