allen的博客

It's never too old to learn

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

在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(); 
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_20641565/article/details/53208909
个人分类: Java
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭