java 锁之 synchronized， Lock，ReadWriteLock 的比较

在java多线程编程中，可能我们经常会遇到线程同步的问题，可以使用synchronized或者Lock和ReadWriteLock去控制同步锁，他们都能实现线程的同步，下面来分析下这几种方式的区别：

1.synchronized
它可以锁住一个方法或者一段代码块，伪代码如下：

//锁住方法
public synchronized void test(){
    doSomething...
} 

//锁住代码块
public synchronized void test(){
    doSomething...
    
    synchronized( any object ){

            锁住的代码块

    }

} 
有多个线程ThreadA、ThreadB…ThreadN等，它们同时去执行一段被synchronized修饰的代码块，如果这里ThreadB抢到了同步锁，那么其他的线程都必须等待，ThreadB只有两种情况下会释放锁：

1）ThreadB执行完了这段代码块，这个锁就会被释放；
2）当ThreadB执行这段代码块抛出异常的时候，jvm虚拟机也会释放这个锁。

如果ThreadB执行时间特别长，那么其他的线程就会一直等待，这样会照成很大的资源浪费，并且没有效率。

2.Lock
它就规避了synchronized的缺点，它是一个接口，里面有如下四个锁方法和一个解锁方法

public interface Lock {
    void lock();  //一直等待获取锁  
    void lockInterruptibly() throws InterruptedException; //一直等待获取锁，可以被中断
    boolean tryLock();   //尝试获取锁一次
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //在时间段内尝试获取锁 ，可以被中断。
    void unlock();  //解锁
}
Lock有一个实现类：ReentrantLock，它实现了Lock里面的方法，但是使用Lock的时候必须注意它不会像synchronized执行完成之后或者抛出异常之后自动释放锁，而是需要你主动释放锁，所以我们必须在使用Lock的时候加上try{}catch{}finally{}块，并且在finally中释放占用的锁资源。

Lock和synchronized最大的区别就是当使用synchronized，一个线程抢占到锁资源，其他线程必须像SB一样得等待；而使用Lock，一个线程抢占到锁资源，其他的线程可以不等待或者设置等待时间，实在抢不到可以去做其他的业务逻辑。

1）lock()这个方法用来获取锁，如果已经被其他线程抢占则等待，最后需要自己释放资源，伪代码如下：

Lock lock = new ReentrantLock(); //多线程共享的lock

 

public void test(){

        doSomething...

        lock.lock();
        try{
            dosomething...
        }catch(Exception e){
            catch exception...
        }finally{
            lock.unlock();
        }

}

2)tryLock()这个方法是当前线程去主动尝试获取锁资源，如果获取成功会有个返回值true，失败即返回false。这样的话拿到锁的线程会去执行锁住的资源，而没拿到资源的会马上返回false不会等待，伪代码如下：

Lock lock = new ReentrantLock();

 

public void test(){

        dosomething...
        boolean flag = lock.tryLock();
        if(flag ){
            try{
                dosomething...
            }catch(Exception e){
                catch exception...
            }finally{
                lock.unlock();
            }
        }

}

3)tryLock(long time, TimeUnit unit)这个方法和上面2的很相似，不过这个会等待一定时间，如果在等待期间获取锁，及当前线程顺利执行资源，反之不等待，伪代码如下(5秒之内抢不到就中断)：

Lock lock = new ReentrantLock();

public void test(){

        dosomething...
       boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
        if(flag ){
            try{
                dosomething...
            }catch(Exception e){
                catch exception...
            }finally{
                lock.unlock();
            }
        }

}
4)lockInterruptibly()这个方法是表示多个线程去抢夺锁资源，ThreadA线程抢到资源并执行的时候，其他线程在等待状态中 ，然后当前线程可以通过interrupt()这个方法使指定的没有抢到锁资源的线程中断等待,如果线程B  接收到中断，则抛出中断异常。test 方法内部需要处理中断异常。

Lock lock = new ReentrantLock();

public void test (){
    dosomething...
    lock.lockInterruptibly();
    try{
        dosomething...

       threadB.interrupt();
    }catch(Exception e){
        catch exception...
    }finally{
        lock.unlock();
    }
}

3.ReadWriteLock（读多写少的场景，读读共享，其他全互斥)
它可以实现读写锁，当读取的时候线程会获得read锁，其他线程也可以获得read锁同时并发的去读取，但是写程序运行获取到write锁的时候，其他线程是不能进行操作的，因为write是排它锁，而上面介绍的两种不管你是read还是write没有抢到锁的线程都会被阻塞或者中断，它也是个接口，里面定义了两种方法readLock()和readLock()，他的一个实现类是ReentrantReadWriteLock。

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}
伪代码如下：

private ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();  //多线程操作共享对象使用的锁。

ThreadA.do{
    read();
    write();
}

ThreadB.do{
    read();
    write();
}

//读操作
void read(){
    rrwl.readLock().lock();
    try{
        read something...
    }catch(exception e){
        catch exception...
    }finally{
        rrwl.readLock().unlock();
    }
}

//写操作
void write(){
    rrwl.writeLock().lock();
    try{
        write something...
    }catch(exception e){
        catch exception...
    }finally{
        rrwl.writeLock().unlock();
    }
}

 

Lock 接口和  ReadWriteLock 接口的区别：

Lock 接口 的实现是 ReentrantLock  

ReadWriteLock 接口的实现是 ReentrantReadWriteLock ，ReentrantReadWriteLock 内部定义的内部类

ReadLock 和 WriteLock 都是实现了 Lock 接口 ，所以 ReadWriteLock 实际上只是 lock 的一层封装，用于更具体的业务场景而已。

 

总结：

1 synchronized 锁分为 偏向锁，轻量锁，重量锁，随着线程并发数越多，锁越重。

Lock 接口 底层实现 也是也实现了这个逻辑，而且还增加了获取锁的时候可以被中断和可以超时的逻辑，可以不用一直等待的逻辑

ReadWriteLock 接口 又扩展了业务场景，把锁分为读锁和写锁，以使用那种读多写少的业务场景。

2 synchronized 的锁原理是在共享对象头里添加标记和对象监控器，这些都是jvm 内部实现的。

而 lock 的锁原理是 独立于共享对象之外 新建一个锁监控对象（锁对象就类似于synchronized 的monitor），需要用户自定义。

synchronized 底层通过monitor 来存储共享对象的并发使用情况，多个线程之间可以通过使用 共享对象.wait 和 共享对象.notify 来实现 多线程 切换。

Lock 也可以实现Object中的notify与wait功能，那就是：Condition

   private Lock lock = new ReentrantLock();
   private Condition condition = lock.newCondition();//多线程操作共享对象使用的锁。

当使用如下的方法就相当于使用Object类的 wait

condition.await();
使用如下方法相当于使用Object类的 notify

condition.signal();    
 

synchronized 和wait notify 的使用：

List list=new Arraylist();//共享对象。

synchronized String  get(){

     if(CollectionUtils.isnotempty(list)){

        list.notify();

       return list.get(0);

     }else{

         list.wait();

    }

}

synchronized String  set(){

     if(CollectionUtils.isnotfull(list)){

        list.add("asdasd);

     list.notify();

     }      else{

list.wait();  

}

}

 

Lock 和 Condition 的使用

List list=new Arraylist(); //共享对象。

private Lock lock = new ReentrantLock();

private Condition condition = lock.newCondition();/

String  get(){

    lock.lock();
        try{
            if(CollectionUtils.isnotempty(list)){

                condition.signal(); return list.get(0);

            }else{condition.await() }
        }catch(Exception e){
            catch exception...
        }finally{
            lock.unlock();
        }

}

String  set(){

   lock.lock();
        try{
            if(CollectionUtils.isnotfull(list)){

                condition.signal(); list.add("ssda);

            }else{condition.await() }
        }catch(Exception e){
            catch exception...
        }finally{
            lock.unlock();
        }

}

以上是如果只有一个读线程和一个写线程的情况下，我们可以这样处理，但是如果有 多个读线程，多个写线程，

如果写的时候发现满了，想要唤醒读线程，但是 notify根本不知道自己唤醒的是读线程，还是写线程。这时候我们就可以用condition 实现了，同一个lock 上可以建立 多个condition ，代码优化如下：

List list=new Arraylist(); //共享对象。

private Lock lock = new ReentrantLock();

private Condition read = lock.newCondition();/

private Condition write = lock.newCondition();/

String  get(){

    lock.lock();
        try{
            if(CollectionUtils.isnotempty(list)){

                 if(list.size==1){ write.signal()}

                 return list.get(0);

            }else{read.await()}
        }catch(Exception e){
            catch exception...
        }finally{
            lock.unlock();
        }

}

String  set(){

   lock.lock();
        try{
            if(CollectionUtils.isnotfull(list)){

              if(list.size==maxsize){ read.signal()}

               list.add("ssda);

            }else{write.await()}
        }catch(Exception e){
            catch exception...
        }finally{
            lock.unlock();
        }

}

对象监视器里的队列分为 等待队列 和正在处理的 队列，正在处理的队列处理完之后发送一个信号通知到等待队列，等待队列的线程收到消息开始处理。

之前使用wait 和notify 实现，但是以上说明了 缺点，当多个读和写线程都在等待的时候，并不能确定唤醒的是哪种线程。

现在用condition 可以把 读队列和写队列 分开，分成了2个队列。通知的时候也只要通知特定队列的线程就可以了。

condition 就是 阻塞线程分组的依据。一部分线程在等待读操作，一部分线程在等待写操作。