自定义的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();
    }
}