synchronized、wait、notify、notifyAll

因为同一个进程的线程之间可以共享同一个进程空间，所以实现线程的数据共享是很容易的（当然在并发中实现数据结构的一致性则另当别论），也可以使用管道流来进行线程通信（没必要）。此处只说协调控制机制

synchronized、wait、notify、notifyAll

使用Java语言内置关键字synchronized来进行加锁，可以保证任务执行的可见性和原子性，从而实现同步执行。synchronized关键字使用的是对象锁，锁的实现依附于对象，避免了锁的创建，所以接下来就直接默认synchronized就是对对象加锁，便于理解。使用方式上，可以显式对对象加锁synchronized(obj){}，也可以隐式对当前对象加锁，就是所谓的同步方法或者synchronized(this){}代码块。这里多说一句，因为synchronized是依附对象的加锁策略，所以在普通方法上加synchronized修饰，加锁范围是当前类的实例，对静态方法上加synchronized修饰，加锁范围为Class类实例，两者属于不同对象，所以不存在竞争问题。

<span style="font-family:FangSong_GB2312;"><span style="font-size:18px;">public class t{
	public static void main(String[] args){
		final test te=new test();
		new Thread(){
			public void run(){
				synchronized(test.class){
					System.out.println("subthread1:"+Thread.currentThread().getId()+"start");
					try{
						Thread.sleep(3000);
					}catch(Exception e){
						e.printStackTrace();
					}
					System.out.println("subthread1:"+Thread.currentThread().getId()+"end");
				}
			}
		}.start();
		
		try{
			Thread.sleep(100);
		}catch(Exception e){
			e.printStackTrace();
		}
		te.plain_meth();
		te.staic_meth();
	}
}
class test{
	public synchronized static void staic_meth(){
		System.out.println("main staic_meth:"+Thread.currentThread().getId());
	}
	public synchronized void plain_meth(){
		System.out.println("main plain_meth:"+Thread.currentThread().getId());
	}
}</span></span>

执行结果

<span style="font-family:FangSong_GB2312;"><span style="font-size:18px;">subthread1:8start
main plain_meth:1
subthread1:8end
main staic_meth:1</span></span>

调用对象的wait方法，使当前线程进入阻塞状态，直到被notify、notifyAll唤醒。notify、notifyAll方法属于大范围无差别唤醒策略，当前进程空间内的所有调用wait进入阻塞状态的线程都可能响应，没有针对性。

生产者消费者示例

<span style="font-family:FangSong_GB2312;"><span style="font-size:18px;">public class t{
	private static final int CAPACITY = 3;
	public static void main(String[] args){
		Buff buf=new Buff(CAPACITY);
		for(int i=0;i<10;i++){
			new Producer("Producer "+i,buf).start();
			new Consumer("Consumer "+i,buf).start();
		}
	}
}
class Buff{
	private final Object[] obj;
	private int index=0;
	public Buff(int CAPACITY){
		obj=new Object[CAPACITY];
	}
	public void put(Object o){
		obj[index++]=o;
	}
	public Object take(){
		return obj[--index];
	}
	public boolean isEmpty(){
		return index==0;
	}
	public boolean isFull(){
		return obj.length==index;
	}
	public int getContent(){
		return index;
	}
}
class Producer extends Thread{
	private Buff buf;
	public Producer(String name,Buff buf){
		super(name);
		this.buf=buf;
	}
	public void run(){
		produce();
	}
	private void produce(){
		synchronized(buf){
			while(buf.isFull()){
				try{
					buf.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			buf.put(new Object());
			System.out.println(Thread.currentThread().getName()+" put a product");
			System.out.println("concurrent buf content: "+buf.getContent());
			buf.notify();
		}
	}
}
class Consumer extends Thread{
	private Buff buf;
	public Consumer(String name,Buff buf){
		super(name);
		this.buf=buf;
	}
	public void run(){
		consume();
	}
	private void consume(){
		synchronized(buf){
			while(buf.isEmpty()){
				try{
					buf.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			buf.take();
			System.out.println(Thread.currentThread().getName()+" take a product");
			System.out.println("concurrent buf content: "+buf.getContent());
			buf.notify();
		}
	}
}
</span></span>

这里说一下，生产者线程判断buf不满使用的检查条件是while(buf.isFull()){}，这里使用while循环而不是if判断。因为当某一个消费者线程con调用了notify后，会有某个因为wait而阻塞的生产者线程pro被唤醒，但是此时con仍然占据锁，需要等con代码块执行完毕，释放锁后，pro获得锁开始执行，如果con脑袋秀逗了，notify后，加了一句buf.put(new Object())，则pro在if语句的wait醒来后，直接向下执行，可能抛出越界异常。

总结

Synchronized、wait、notify、notifyAll可以实现一定程度的线程协调作用，但是在灵活性方面做的不好，引入Lock、Condition可以在一方面弥补这些缺陷，当然API层次的locks包也有不足。