Java中synchronized关键字和Lock的区别与关联：

1、 synchronized的实现是由JVM来控制的，而synchronized不论是修饰方法还是同步代码块，拿到的都是对象的锁。

当synchronized修饰的是方法时，synchronized所拿到的是调用该方法的对象的锁，一般情况下都是this的锁；
当synchronized()修饰的同步代码块时，synchronized拿到的是指定对象的锁。
当synchronized作用于静态方法时，拿到的是这个方法所属Class对象的锁。在Java中，每一个对象都有一个锁，可以通过synchronized来获取。

2、Lock接口是属于JDK层面的，锁的释放必须手动执行。

3、关于synchronized和lock的选取，

1）Lock能够响应中断，让处于等待状态的线程停止等待，而synchronized不行；

2）synchronized在发生异常时，能够自动释放锁，所以不会发生死锁情况；而Lock必须在finally中主动unlock锁，否则就会出现死锁。

3）Lock能够判断是否获取到锁，提高了多线程下对读操作的性能。

public class ReadWriteLockDemon {

    static Map<String, Object> map = new HashMap<String,Object>();
    static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public static Object getData(String key){
        lock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }


    public static void putData(String key, Object data){
        lock.writeLock().lock();
        try {
            map.put(key,data);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void clear(){
        lock.writeLock().lock();
        try {
            map.clear();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

4、读写锁的自我实现

public class ReadWriteLock {
    private int writers = 0;
    private int readers = 0;
    private int writerequest = 0;

    public synchronized void lockRead() throws InterruptedException {
        while(writers >0 || writerequest >0){
            wait();
        }
        readers++;
    }

    public synchronized void unLockRead(){
        readers--;
        notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException {
        writerequest++;
        while(readers>0 || writers>0){
            wait();
        }
        writers++;
        writerequest--;
    }

    public synchronized void unLockWrite(){
        writers--;
        notifyAll();
    }

}

上面读写锁的实现参考文献《
Java中的读/写锁》。但是对于此种不可重入的读写锁有一个问题：

有两个线程，线程1请求读锁，线程2请求写锁，但因为线程1读锁存在，线程2被阻塞；当线程1再次请求读锁的时候，因为线程2写锁阻塞，所以线程1也会被阻塞，不会再有线程成功获取到锁，造成了死锁现象。