Lock和读写锁ReadWriteLock和缓存实例

1：lock和synchronized对比

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


 public   class  LockTest {

     /**
      * @param args
      */
     public   static   void  main(String[] args) {
         new  LockTest().init();
     }

     private   void  init(){
         final  Outputer outputer =  new  Outputer();
         new  Thread( new  Runnable(){
             @Override
             public   void  run() {
                 while ( true ){
                     try  {
                         Thread.sleep(10 );
                     } catch  (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     outputer.output("zhangxiaoxiang" );
                 }

             }
         }).start();

         new  Thread( new  Runnable(){
             @Override
             public   void  run() {
                 while ( true ){
                     try  {
                         Thread.sleep(10 );
                     } catch  (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     outputer.output("lihuoming" );
                 }

             }
         }).start();

     }

     static   class  Outputer{
         Lock lock = new  ReentrantLock();
         public   void  output(String name){
             int  len = name.length();
             lock.lock();
             try {
                 for ( int  i= 0 ;i<len;i++){
                     System.out.print(name.charAt(i));
                 }
                 System.out.println();
             }finally {
                 lock.unlock();
             }
         }

         public   synchronized   void  output2(String name){
             int  len = name.length();
             for ( int  i= 0 ;i<len;i++){
                     System.out.print(name.charAt(i));
             }
             System.out.println();
         }

         public   static   synchronized   void  output3(String name){
             int  len = name.length();
             for ( int  i= 0 ;i<len;i++){
                     System.out.print(name.charAt(i));
             }
             System.out.println();
         }
     }
 }

2.读写锁：ReadWriteLock

 import  java.util.Random;
 import  java.util.concurrent.locks.ReadWriteLock;
 import  java.util.concurrent.locks.ReentrantReadWriteLock;

 public   class  ReadWriteLockTest {
     public   static   void  main(String[] args) {
         final  Queue3 q3 =  new  Queue3();
         for ( int  i= 0 ;i< 3 ;i++)
         {
             new  Thread(){
                 public   void  run(){
                     while ( true ){
                         q3.get();
                     }
                 }

             }.start();

             new  Thread(){
                 public   void  run(){
                     while ( true ){
                         q3.put(new  Random().nextInt( 10000 ));
                     }
                 }

             }.start();
         }

     }
 }

 class  Queue3{
     private  Object data =  null ; //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
     ReadWriteLock rwl = new  ReentrantReadWriteLock();
     public   void  get(){
         rwl.readLock().lock();
         try  {
             System.out.println(Thread.currentThread().getName() + " be ready to read data!" );
             Thread.sleep((long )(Math.random()* 1000 ));
             System.out.println(Thread.currentThread().getName() + "have read data :"  + data);
         } catch  (InterruptedException e) {
             e.printStackTrace();
         }finally {
             rwl.readLock().unlock();
         }
     }

     public   void  put(Object data){

         rwl.writeLock().lock();
         try  {
             System.out.println(Thread.currentThread().getName() + " be ready to write data!" );
             Thread.sleep((long )(Math.random()* 1000 ));
             this .data = data;
             System.out.println(Thread.currentThread().getName() + " have write data: "  + data);
         } catch  (InterruptedException e) {
             e.printStackTrace();
         }finally {
             rwl.writeLock().unlock();
         }


     }
 }

3.用读写锁实现一个简单缓存机制

 import  java.util.HashMap;
 import  java.util.Map;
 import  java.util.concurrent.locks.ReadWriteLock;
 import  java.util.concurrent.locks.ReentrantReadWriteLock;

 public   class  CacheDemo {

     private  Map<String, Object> cache =  new  HashMap<String, Object>();
     public   static   void  main(String[] args) {
         // TODO Auto-generated method stub

     }

     private  ReadWriteLock rwl =  new  ReentrantReadWriteLock();
     public   Object getData(String key){
         rwl.readLock().lock();
         Object value = null ;
         try {
             value = cache.get(key);
             if (value ==  null ){
                 rwl.readLock().unlock();
                 rwl.writeLock().lock();
                 try {
                     if (value== null ){
                         value = "aaaa" ; //实际失去queryDB();
                     }
                 }finally {
                     rwl.writeLock().unlock();
                 }
                 rwl.readLock().lock();
             }
         }finally {
             rwl.readLock().unlock();
         }
         return  value;
     }
 }