ReentrantLockCondition锁与Synchronized在多线程中的使用

    生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。
问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一个或者多个数据后再去唤醒它。
同样地，当缓冲区已经空了，而消费者还想去取消息，此时也可以让消费者进行休眠，等待生产者放入一个或者多个数据时再唤醒它。

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。

其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入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;//如果写索引写到队列的最后一个位置了，那么置为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;//如果读索引读到队列的最后一个位置了，那么置为0

       --count;//个数--

       notFull.signal();//唤醒写线程

       return x;

     } finally {

       lock.unlock();

     }

   } 

 }

浅谈Synchronized:

　　synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程

便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况:

　　1).获取锁的线程执行完该代码块,然后线程释放对锁的占有;

　　2).线程执行发生异常,此时JVM会让线程自动释放锁;

3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁.

Lock的特性:

　　1).Lock不是Java语言内置的;

　　2).synchronized是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁,但是Lock不行,要保证锁一定会被释放,就必须将unLock放到finally{}中(手动释放);

　　3).在资源竞争不是很激烈的情况下,Synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;

　　4).ReentrantLock增加了锁:

　　　　a. void lock(); // 无条件的锁;

　　　　b. void lockInterruptibly throws InterruptedException;//可中断的锁;

解释:　　使用ReentrantLock如果获取了锁立即返回,如果没有获取锁,当前线程处于休眠状态,直到获得锁或者当前线程可以被别的线程中断去做其他的事情;但是如果是synchronized的话,如果没有获取到锁,则会一直等待下去;

　　　　c. boolean tryLock();//如果获取了锁立即返回true,如果别的线程正持有,立即返回false,不会等待;

　　　　d. boolean tryLock(long timeout,TimeUnit unit);//如果获取了锁立即返回true,如果别的线程正持有锁,会等待参数给的时间,在等待的过程中,如果获取锁,则返回true,如果等待超时,返回false;

Condition的特性:

　　　　1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。

　　　　2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
　　　　例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，"读线程"需要等待。      

　　　　  如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。  但是，通过Condition，就能明确的指定唤醒读线程。

ReentrantLock有公平锁与非公平锁之分：公平锁（按照等待顺序执行）非公平锁（执行顺序随机）公平锁、非公平锁的创建方式：

//创建一个非公平锁，默认是非公平锁

Lock lock = new ReentrantLock();

Lock lock = new ReentrantLock(false);

 

//创建一个公平锁，构造传参true

Lock lock = new ReentrantLock(true);

其中candition中的awaitUntil为等待时间在超过设定的等待时间或者有signal或者signalAll时唤醒。

例如 boolean v = event.awaitUntil(2000);当超过2秒或者有该condition的signal时触发继续执行。

大部分情况下lock与ThreadLoca线程内存一起使用