java并发中Lock和Synchronized的异同

java中可以使用Lock和Synchronized的可以实现对某个共享资源的同步，同时也可以实现对某些过程的原子性操作
Lock可以使用Condition进行线程之间的调度
Synchronized则使用Object对象本身的notify, wait, notityAll调度机制
这两种调度机制有什么异同呢？
Condition是Java5以后出现的机制，它有更好的灵活性，而且在一个对象里面可以有多个Condition（即对象监视器),则线程可以注册在不同的Condition，从而可以有选择性的调度线程，更加灵活。
Synchronized就相当于整个对象只有一个单一的Condition（即该对象本身）所有的线程都注册在它身上，线程调度的时候之后调度所有得注册线程，没有选择权，会出现相当大的问题
下面是一个场景，针对这个场景提出两种解决方案。
一个中转站，可以接纳货物，然后发出货物，这是需要建一个仓库，相当于一个缓冲区，当仓库满的时候，不能接货，仓库空的时候，不能发货。
第一种，用一个Condition去解决，有可能会出问题

package com.zxx;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 单个Condition去控制一个缓冲区，多线程对缓冲区做读写操作，要保证缓冲区满的时侯不会
 * 被写，空的时候不会被读；单个Condition控制会出错误： 当缓冲区还有一个位置时，多个写线程
 * 同时访问，则只有一个写线程可以对其进行写操作，操作完之后，唤醒在这个condition上等待的
 * 其他几个写线程，如果判断用IF语句的话就会出现继续向缓冲区添加。
 * @author Administrator
 *
 */
public class ConditionError {
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	String[] container = new String[10];
	int index = 0;
	public static void main(String[] args) {
		ConditionError conditionError = new ConditionError();
		conditionError.test();
	}

	public void test(){
		ExecutorService threadPool = Executors.newCachedThreadPool();
		for(int i = 0; i < 14; i++){//先用14个线程去写，则有4个线程会被阻塞
			threadPool.execute(new Runnable(){

				@Override
				public void run() {
					put();
				}

			});
		}

		Executors.newSingleThreadExecutor().execute(new Runnable(){//用一个线程去取，则会通知4个阻塞的写线程工作，此时
																//会有一个线程向缓冲区写，写完后去通知在这个condition上等待
																//的取线程，这是它的本意，但是它唤醒了写线程，因为只有一个condition
																//不能有选择的唤醒写取线程，此时就需要有多个Condition
			@Override
			public void run() {
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				get();
			}

		});
	}

	/**
	 * 向缓冲去写数据
	 */
	public void put(){
		lock.lock();
		try{
			System.out.println(Thread.currentThread().getName() + "当前位置:" + index + "-----------------------------");
			while(index == 10){
				try {
					System.out.println(Thread.currentThread().getName() + "处于阻塞状态！");
					condition.await();
//					index = 0;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			container[index] = new String(new Random().nextInt() + "");
			condition.signalAll();
			index ++;
		} finally {
			lock.unlock();
		}
	}

	/**
	 * 从缓冲区拿数据
	 */
	public void get(){
		lock.lock();
		try{
			while(index == 0){
				try {
					System.out.println("get--------" + Thread.currentThread().getName() + "处于阻塞");
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			index --;
			System.out.println("get---------" + Thread.currentThread().getName() + "唤醒阻塞");
			condition.signalAll();


		} finally {

			lock.unlock();
		}
	}
}

第二种解决方案，用java api中的 一个例子

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length) 
         notFull.await();
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0) 
         notEmpty.await();
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }

请注意，
[color=red]
（ArrayBlockingQueue 类提供了这项功能，因此没有理由去实现这个示例类。）[/color][size=medium][/size]