到底什么是线程间的通信？

线程间需要通过一些协调性的通信，实现共同完成同一件任务，简单说就是，你想做这件事，我也想做这件事，我们两个相互交流，共同做这件事，而共同任务的同步性的实现，就必须通过同步锁，每一个对象实例都有自己的一把锁，当一个线程想要对这个任务进行处理的时候，就必须获得这把锁。线程之间锁的释放与获取，是通过Object类中的wait()/notify()方法实现的。wait()方法是将当前拥有锁的线程至于等待状态让其释放锁，而notify()方法是唤醒其他线程使其具备执行资格，过来拿这个锁，拿到这个锁后才具备了执行权。

需要注意的是，一定要确保wait()方法是出于同步区域中，才会拥有锁，而同样至于同步区域的Thread.sleep（）方法，只会让线程在指定的时间段内睡眠，而不会释放锁

线程间的通信主要通过两种方式：

1.共享内存

初次学习的时候，已经写过，写个简单点的

public class Main{
	public static void main(String[] args){
		MemoryThread MyThread = new MemoryThread();
		MyThread.getThread().start();
		MyThread.getThread().start();
	}
}
class MemoryThread {
	private int data;
	public MemoryThread() {
		// TODO Auto-generated constructor stub
		data = http://www.mamicode.com/0;>

ps：共享内存这中通信方式，存在不稳定性，有时候会出现问题

2.管道流
通过管道流实现线程间的通信，主要是将管道流连接到线程。
class Producer implements Runnable{

	private PipedOutputStream pout = null;
	public Producer(PipedOutputStream pout) {
		
		this.pout = pout;
	}
	public void run() {
		int x = 1;
		// TODO Auto-generated method stub
		synchronized (this) {
			
			while(true){	
				synchronized (this) {
						try {
							System.out.println("Producer set "+x);
						pout.write(x);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}			
		}	
	}
}
class Customer implements Runnable{

	private PipedInputStream pin = null;
	public Customer(PipedInputStream pin) {
		
		this.pin = pin;
	}
	public void run() {
		
			while(true){
				synchronized(this){
				try {
					System.out.println("Customer get "+pin.read());
				} catch (Exception e) {
					// TODO: handle exception
				}
				
			}
		}
		
	}	
}
public class Main{
	
	public static void main(String[] args) {
		
		PipedInputStream pin = new PipedInputStream();
		PipedOutputStream pot = new PipedOutputStream();
		try{
			pot.connect(pin);
		}catch(Exception e){
			e.printStackTrace();
			
		}
		new Thread(new Producer(pot)).start();
		new Thread(new Customer(pin)).start();
		
	}
}

ps：因为管道流的read方法是阻塞式的，数据的同步和并发会出现问题

由线程间的通信问题进而可以提升到多生产者多消费者问题
多生产者多消费者问题解决方法一般分为两种：
1.采用一种机制实现生产者/消费者间的同步（常用，效率高）
2.采用管道流的方式
解决同步问题，一般都是synchronized函数或代码块+while+notifyAll的方式，接口Lock的出现，有了更加灵活的操作，可以支持多个监听器，以此来实现锁更广泛的操作

此处直接演示Lock的方式

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by kevy on 14-12-01.
 */

/**
 * 描述：仓库存储着货物，每个货物都对应一个编号
 * 仓库货满时，生产者不能存放货物。 仓库为空时，消费者不能拿走货物
 * 面向对象的思想考虑问题：涉及的对象，生产者，消费者，货物，仓库
 * 生产者，消费者对应着同一个仓库，仓库对应着不同的货物
 */
class Goods {
    private String name;
    private int num;
    Goods(String name,int num){
        this.name = name;
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public int getNum() {
        return num;
    }
}
class StoreHouse{
    public final static int SIZE = 10;
    private Goods[] goodses = new Goods[SIZE];//定义仓库储存大小

    private Lock lock = new ReentrantLock();//创建锁
    private Condition Pro_lock = lock.newCondition();//创建生产者监视器
    private Condition Cus_lock = lock.newCondition();//创建消费者监视器
    private int putnum = 0,count = 0,takenum = 0;

    public void set(Goods good){
        lock.lock();
        try{
            while(count==SIZE){
                try{
                    Pro_lock.await();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            Thread.sleep(100);//延时100
            goodses[putnum] = good;
            System.out.println(Thread.currentThread().getName()+"++++生产++++"+
                    good.getName()+good.getNum());
            if(++putnum==SIZE) putnum = 0;
            count++;
            Cus_lock.signal();

           }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void out(){
        lock.lock();
        try{
            while(count==0){
                try{
                    Cus_lock.await();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            Thread.sleep(100);//延时100
            Goods item = goodses[takenum];
            if(++takenum==SIZE) takenum = 0;
            --count;
            System.out.println(Thread.currentThread().getName()+"----消费----"+
                item.getName()+item.getNum());
            Pro_lock.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
class Producer implements Runnable{
    private StoreHouse storeHouse = null;
    private String Goodname = null;
    Producer(StoreHouse storeHouse,String goodname){
        this.storeHouse = storeHouse;
        this.Goodname = goodname;
    }

    public void run() {
        int NUM = 1;
        while(true){
            storeHouse.set(new Goods(Goodname,NUM++));
        }
    }
}
class Customer implements Runnable{
    private StoreHouse storeHouse = null;
    Customer(StoreHouse storeHouse){
        this.storeHouse = storeHouse;
    }

    public void run() {
        while(true){
            storeHouse.out();
        }
    }
}
public class Main {
    public static StoreHouse storeHouse;
    public static void main(String[] args){

        storeHouse = new StoreHouse();
        Runnable p = new Producer(storeHouse,"卫生纸");
        Runnable p1 = new Producer(storeHouse,"Java技术-核心卷I");

        Runnable c = new Customer(storeHouse);
        Runnable c1 = new Customer(storeHouse);

        Thread proThread1 = new Thread(p);//生产者线程
        Thread proThread2 = new Thread(p1);
        Thread cusThread1 = new Thread(c);//消费者线程
        Thread cusThread2 = new Thread(c1);

        proThread1.start();  cusThread1.start();
        proThread2.start();  cusThread2.start();

    }
}








Java多线程间的通信问题扩展