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
                     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
                     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
                     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.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
	public static boolean flag = true;

	public static void main(String[] args) {
		final Queue3 q3 = new Queue3();
		for (int i = 0; i < 3; i++) {

			new Thread() {
				public void run() {
					while (ReadWriteLockTest.flag) {
						q3.put();
					}
				}
			}.start();
		}
	}
}

class Queue3 {

	private Integer data = 10;// 共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
	final ReadWriteLock lock = new ReentrantReadWriteLock();

	public void put() {
		lock.writeLock().lock();// 写锁开启，这时只有一个写线程进入
		try {
			System.out.println(Thread.currentThread().getName() + " have write data: " + data);
			if (data == 0) {
				ReadWriteLockTest.flag = false;
				return;
			}
			data--;
		} finally {
			lock.writeLock().unlock();
		}

	}
}

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

 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 cache = new HashMap();
     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;
     }
 }