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(){@Overridepublic void run() {put();}});}Executors.newSingleThreadExecutor().execute(new Runnable(){//用一个线程去取，则会通知4个阻塞的写线程工作，此时//会有一个线程向缓冲区写，写完后去通知在这个condition上等待//的取线程，这是它的本意，但是它唤醒了写线程，因为只有一个condition//不能有选择的唤醒写取线程，此时就需要有多个Condition@Overridepublic 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();     }   }  }

请注意，

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