高性能锁ReentrantReadWriteLock

多线程读取并修改一个资源时，通常使用synchronized同步锁。性能损失情况很严重。jdk5.0以后提供了新的ReentrantReadWriteLock可以提供比synchronized更高性能的并发。

Dictionary.java

package com.test;

import java.util.HashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Dictionary {

    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private final Lock read = readWriteLock.readLock();

    private final Lock write = readWriteLock.writeLock();

    private HashMap<String, String> dictionary = new HashMap<String, String>();

    public void set(String key, String value) {
        write.lock();
        try {
            dictionary.put(key, value);
        } finally {
            write.unlock();
        }
    }

    public String get(String key) {
        read.lock();
        try {
            return dictionary.get(key);
        } finally {
            read.unlock();
        }
    }

    public String[] getKeys() {
        read.lock();
        try {
            String keys[] = new String[dictionary.size()];
            return dictionary.keySet().toArray(keys);
        } finally {
            read.unlock();
        }
    }

    public static void main(String[] args) {
        Dictionary dictionary = new Dictionary();
        dictionary.set("java", "object oriented");
        dictionary.set("linux", "rulez");
        //dictionary.set("C++", "lanjh");
        Writer writer = new Writer(dictionary, "Mr. Writer ");
        //Writer writer2 = new Writer(dictionary, "Mr. Writer 2");
        Reader reader1 = new Reader(dictionary, "Mrs Reader 1");
        Reader reader2 = new Reader(dictionary, "Mrs Reader 2");
        Reader reader3 = new Reader(dictionary, "Mrs Reader 3");
        Reader reader4 = new Reader(dictionary, "Mrs Reader 4");
        Reader reader5 = new Reader(dictionary, "Mrs Reader 5");
        writer.start();
        //writer2.start();
        reader1.start();
        reader2.start();
        reader3.start();
        reader4.start();
        reader5.start();
    }
}

Reader.java

package  com.test;

public   class  Reader  extends  Thread{
       
        private  Dictionary dictionary  =   null ;
        public  Reader(Dictionary d, String threadName) {
          this .dictionary  =  d;
          this .setName(threadName);
       }
       
        private   boolean  runForestRun  =   true ;

        public   void  run() {
          while  (runForestRun) {
           String [] keys  =  dictionary.getKeys();
            for  (String key : keys) {
              // reading from dictionary with READ LOCK
             String value  =  dictionary.get(key);
             
              // make what ever you want with the value.
             System.out.println( this .getName() + "  =  " + key  +   "  :  "   +  value);
           }
           
            // update every seconds
            try  {
             Thread.sleep( 1000 );
           }  catch  (InterruptedException e) {
             e.printStackTrace();
           }
         }
       }
       
        public   void  stopReader(){
          this .runForestRun  =   false ;
          this .interrupt();
       }
     }

Writer.java

package  com.test;

public   class  Writer  extends  Thread{
        private   boolean  runForestRun  =   true ;
        private  Dictionary dictionary  =   null ;
       
        public  Writer(Dictionary d, String threadName) {
          this .dictionary  =  d;
          this .setName(threadName);
       }
       @Override
        public   void  run() {
          while  ( this .runForestRun) { 
           String [] keys  =  dictionary.getKeys();
            for  (String key : keys) {
             String newValue  =  getNewValueFromDatastore(key);
              // updating dictionary with WRITE LOCK
             dictionary.set(key, newValue);
             System.out.println( this .getName() + "  =  " + key  +   "  :  "   +  newValue);

           }
           
            // update every seconds
            try  {
             Thread.sleep( 1000 );
           }  catch  (InterruptedException e) {
             e.printStackTrace();
           }
         }
       }
        public   void  stopWriter(){
          this .runForestRun  =   false ;
          this .interrupt();
       }
        public  String getNewValueFromDatastore(String key){
          // This part is not implemented. Out of scope of this artile
          return  key;
       }
     }