读写锁 ReentrantReadWriteLock

读操作的时候 所有的线程可以一起执行. 上读锁，其他线程只能读不能写

写操作的时候 会锁定一个线程.         上写锁，不允许其他线程读也不允许写

自定义的map

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class LockMap<K, V> extends ILock
{
	private HashMap<K, V> map = new HashMap<K, V>();
	
	public HashMap<K, V> getMap()
	{
		HashMap<K, V> map = new HashMap<K, V>();
		ReadLock().lock();
		try
		{
			map.putAll(map);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			ReadLock().unlock();
		}
		return map;
	}
	
	public List<K> getKeys()
	{
		ReadLock().lock();
		try
		{
			return new ArrayList<K>(map.keySet());
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			ReadLock().unlock();
		}
		return null;
	}
	
	public List<V> getValues()
	{
		ReadLock().lock();
		try
		{
			return new ArrayList<V>(map.values());
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			ReadLock().unlock();
		}
		return null;
	}
	
	public V get(K key)
	{
		ReadLock().lock();
		try
		{
			if(map.containsKey(key))
			{
				return map.get(key);
			}
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			ReadLock().unlock();
		}
		return null;
	}
	
	public int size()
	{
		ReadLock().lock();
		try
		{
			return map.size();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			ReadLock().unlock();
		}
		return 0;
	}
	
	public void clear()
	{
		WriteLock().lock();
		try
		{
			map.clear();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			WriteLock().unlock();
		}
	}
	
	public void put(K key, V value)
	{
		WriteLock().lock();
		try
		{
			map.put(key, value);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			WriteLock().unlock();
		}
	}
	
	public void remove(K key)
	{
		WriteLock().lock();
		try
		{
			if(map.containsKey(key))
			{
				map.remove(key);
			}
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			WriteLock().unlock();
		}
	}
}

ILock

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

public abstract class ILock
{
	private ReadWriteLock meadWriteLock = new ReentrantReadWriteLock();
	
	protected final Lock ReadLock()
	{
		return meadWriteLock.readLock();
	}
	
	protected final Lock WriteLock()
	{
		return meadWriteLock.writeLock();
	}
}