lock+Condition

关键字 synchronized+wait/notify/notifyAll可以实现等待/通知模式，类ReentrantLock可以实现同样的功能，但需要借助Condition对象。Condition类是JDK5中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，选择性的进行线程通知，在调度线程上更加灵活。

使用wait+notify/notifyAll方法进行通知时，被通知的线程却是由JVM随机选择的。但使用reentrantLock结合Condition类是可以实现选择性通知。

Object类中的wait()方法，相当于Condition类中的await()方法；Object类中的notify()方法，相当于Condition类中的signal()方法。Object类中的notifyAll方法，相当于Condition类中的signalAll()方法。

打印 12A34B.......5152Z

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

 public class Print12A_RC {

     private Lock lock =new ReentrantLock();
     private Condition con=lock.newCondition();
     private boolean isInt=true;
     private int i=1;
     private char ch ='A';
     public void printInt()
     {
         try {
             lock.lock();
             while(!isInt)
             {
                 con.await();
             }
             System.out.print((i++)+""+(i++));
             isInt=false;
             con.signal();
         } catch (Exception e) {
         }
         finally
         {
             lock.unlock();
         }
     }

     public void printChar()
     {
         try {
             lock.lock();
             while(isInt)
             {
                 con.await();
             }
             System.out.print((char)ch);
             ch++;
             isInt=true;
             con.signal();

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

     public static void main(String[] args) {
         Print12A_RC rc=new Print12A_RC();
         Thread aThread=new Thread(new Runnable() {

             @Override
             public void run() {
                 for(int i=0;i<26;i++)
                 {
                     rc.printInt();
                 }
             }
         });
         Thread bThread =new Thread(new Runnable() {

             @Override
             public void run() {
                 for(int i=0;i<26;i++)
                 {
                     rc.printChar();
                 }
             }
         });
         aThread.start();
         bThread.start();
     }
 }

顺序打印，如123123123....

 package multiMethod.reentrantLockCondition;

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

 public class PrintByOrder {
     ReentrantLock lock =new ReentrantLock();
     Condition condition=lock.newCondition();
     int printnext=1;

     public void print1()
     {
         lock.lock();
         try{
             while(printnext!=1)
             {
                 condition.await();
             }
             Thread.sleep(500);//不加此行会不打印，不知什么原因。
             System.out.print(1);
             printnext=2;
             condition.signalAll();
         }
         catch (Exception e) {
             // TODO: handle exception
         }
         finally{
             lock.unlock();
         }
     }

     public void print2()
     {
         lock.lock();
         try{
             while(printnext!=2)
             {
                 condition.await();
             }
             System.out.print(2);
             printnext=3;
             condition.signalAll();
         }
         catch (Exception e) {
         }
         finally{
             lock.unlock();
         }
     }

     public void print3()
     {
         lock.lock();
         try{
             while(printnext!=3)
             {
                 condition.await();
             }
             System.out.print(3);
             printnext=1;
             condition.signalAll();
         }
         catch (Exception e) {
             // TODO: handle exception
         }
         finally{
             lock.unlock();
         }
     }

     public static void main(String[] args) {
         PrintByOrder order=new PrintByOrder();
         Runnable runnable1=new Runnable() {

             @Override
             public void run() {
                 while(true){
                     order.print1();
                 }
             }
         };

         Runnable runnable2=new Runnable() {

             @Override
             public void run() {
                 while(true){
                     order.print2();
                 }
             }
         };

         Runnable runnable3=new Runnable() {

             @Override
             public void run() {
                 while(true){
                     order.print3();
                 }
             }
         };

         new Thread(runnable1).start();
         new Thread(runnable2).start();
         new Thread(runnable3).start();
     }
 }

读写锁，比上面的lock+condition提高效率。

ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁
线程进入读锁的前提条件：
    没有其他线程的写锁，
    没有写请求或者有写请求，但调用线程和持有锁的线程是同一个

线程进入写锁的前提条件：
    没有其他线程的读锁
    没有其他线程的写锁

简单来说，就是读读共享，写写互斥，读写互斥。

另外，ReentrantReadWriteLock.readLock 无需newCondition，而ReentrantReadWriteLock.writeLock可以newCondition，用于多个读线程之间的通信。

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 public class ReadWriteLock {
     private ReentrantReadWriteLock rw= new ReentrantReadWriteLock();

     public void readLock(){

         try {
             rw.readLock().lock();
             System.out.println("read before sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
             Thread.sleep(2000);
             System.out.println("read after sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
         } catch (Exception e) {
             // TODO: handle exception
         }finally{
             rw.readLock().unlock();
         }
     }

     public void writeLock(){

         try {
             rw.writeLock().lock();
             System.out.println("write before sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
             Thread.sleep(2000);
             System.out.println("write after sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
         } catch (Exception e) {
             // TODO: handle exception
         }finally{
             rw.writeLock().unlock();
         }
     }

     public static void main(String[] args) {
         ReadWriteLock rwl=new ReadWriteLock();
         Runnable runnable=new Runnable() {

             @Override
             public void run() {
                 rwl.writeLock();
                 rwl.readLock();

             }
         };
         Thread[] threads=new Thread[10];
         for(int i=0;i<5;i++)
         {
             threads[i]=new Thread(runnable);
         }
         for(int i=0;i<5;i++)
         {
             threads[i].start();
         }
     }

 }