转: Lock、synchronized和ReadWriteLock的区别和联系以及Condition

ゝ一世哀愁。 2022-05-20 08:48 203阅读 0赞

原文地址: https://blog.csdn.net/qq\_20641565/article/details/53208909

在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();
    //线程1
    new Thread(){
        run(){
            dosomething...
            lock.lock();
            try{
                dosomething...
            }catch(Exception e){
                catch exception...
            }finally{
                lock.unlock();
            }
        }
    }.start();
    
    //线程2
    new Thread(){
        run(){
            dosomething...
            lock.lock();
            try{
                dosomething...
            }catch(Exception e){
                catch exception...
            }finally{
                lock.unlock();
            }
        }
    }.start();

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

Lock lock = new ReentrantLock();
    //线程1
    new Thread(){
        run(){
            dosomething...
            boolean flag = lock.tryLock();
            if(flag ){
                try{
                    dosomething...
                }catch(Exception e){
                    catch exception...
                }finally{
                    lock.unlock();
                }
            }
        }
    }.start();
    //线程2
    new Thread(){
        run(){
            dosomething...
            boolean flag = lock.tryLock();
            if(flag ){
                try{
                    dosomething...
                }catch(Exception e){
                    catch exception...
                }finally{
                    lock.unlock();
                }
            }
        }
    }.start();

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

Lock lock = new ReentrantLock();
    //线程1
    new Thread(){
        run(){
            dosomething...
            boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
            if(flag ){
                try{
                    dosomething...
                }catch(Exception e){
                    catch exception...
                }finally{
                    lock.unlock();
                }
            }
        }
    }.start();
    //线程2
    new Thread(){
        run(){
            dosomething...
            boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
            if(flag ){
                try{
                    dosomething...
                }catch(Exception e){
                    catch exception...
                }finally{
                    lock.unlock();
                }
            }
        }
    }.start();

4)lockInterruptibly()这个方法是表示多个线程去抢夺锁资源，ThreadA线程抢到资源并执行的时候，其他线程在等待状态中，但是我们可以通过interrupt()这个方法使指定没有抢到锁资源的线程中断等待。

Lock lock = new ReentrantLock();
    ThreadA.start();
    ThreadB.start();
    
    dosomething....
    
    ThreadB.interrupt();
    
    run(){
        dosomething...
        boolean flag = lock.lockInterruptibly();
        try{
            dosomething...
        }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 readLock();
    }

伪代码如下：

private ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();
    
    ThreadA.do{
        read();
        write();
    }
    
    ThreadB.do{
        read();
        write();
    }
    
    //读操作
    read(){
        rrwl.readLock().lock();
        try{
            read something...
        }catch(exception e){
            catch exception...
        }finally{
            rrwl.readLock().unlock();
        }
    }
    
    //写操作
    write(){
        rrwl.writeLock().lock();
        try{
            write something...
        }catch(exception e){
            catch exception...
        }finally{
            rrwl.writeLock().unlock();
        }
    }

使用ReentrantLock 也可以实现Object中的notify与wait功能（这两个方法需要配合synchronized关键字使用）。

那就是：Condition

private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();

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

condition.await();

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

condition.signal();

**`CAS技术:`**

CAS的思想很简单：三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。

CAS的缺点：会出现ABA问题,就是本来值是A后来改成了B又改变为A，而你不知道这个过程；

ABA的解决方案：

J.U.C提供了一个带标记的原子引用类"AtomicStampedReference",但是采用传统的互斥同步可能会比这个效率更高。