多线程八 Lock

前面我们可以使用synchronized关键字来实现线程之间的同步互斥,lock接口同样也是在JDK1.5中提出,同样是解决线程安全性问题的另一种解决方案,而且它更强大,更灵活本片博客介绍对其展开介绍;

Lock接口有如下几个实现类:

ReentrantLock--JDK实现的锁
ReentrantReadWritrLock.ReadLock
ReentrantReadWriteLock.WriteLock

打个例子

public class Demo01 {

    private int i=0;

 Lock Mylock = new ReentrantLock();

  public int add() throws InterruptedException {

      try{

          Mylock.lock();

          i++;

          return i;

      } finally {

          Mylock.unlock();

      }

      }

如上代码 i++ 被 Mylock.lock()和 Mylock.unlock()围住,显示的获取和释放锁,具有同步性...

其中,ReentrantLock一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

Lock 与 Synchronized 相比较,显而易见的就是,Lock需要显示的去获取锁,释放锁,比较繁琐,但是繁琐带来了更大好处,让代码更灵活...Lock是对Synchronized的封装...

比如:

在控制锁的获取和释放,以及何时何地获取释放
使用Lock,可以很方便的实现锁的公平性ReentrantLock(boolean fair)
强大的API
- 非阻塞获取锁:tryLock()
- 可中断式获取线程acquireSharedInterruptibly(int arg)
- 超时获取线程tryAcquireSharedNanos(int arg , long nanosTimeout)

一 . Conditon&Reentrantlock

1. Condition实现正确的通知/等待

注意点,一定要在condition.wait()方法调用之前,使用lock.lock()方法获取对象同步锁,否则抛出异常

    public void waitMethod(){

        try{

            lock.lock();

            System.out.println(Thread.currentThread().getName()+"等待了..."+System.currentTimeMillis());

            try {

                condition.await();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }finally {

            lock.unlock();

        }

    }

    public void signalMethod(){

        try{

            lock.lock();

            System.out.println(Thread.currentThread().getName()+"被唤醒了..."+System.currentTimeMillis());

            condition.signal();

        }finally {

            lock.unlock();

        }

    }

    public static void main(String[] args) {

        demo1 demo1 = new demo1();

        new Thread(()->{

            demo1.waitMethod();

        }).start();

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        demo1.signalMethod();

    }

}

运行结果:

Thread-0等待了...1549450097987

main被唤醒了...1549450099988

2 使用多个Condition实现,通知部分线程

接下来就是重头戏了Condition控制通知指定的线程醒来

public void waitMethod(){

    try{

        lock.lock();

        System.out.println(Thread.currentThread().getName()+"等待了..."+System.currentTimeMillis());

        try {

            condition.await();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }finally {

        lock.unlock();

    }

}

public void signalMethod(){

    try{

        lock.lock();

        System.out.println(Thread.currentThread().getName()+"被唤醒了..."+System.currentTimeMillis());

        condition.signal();

    }finally {

        lock.unlock();

    }

}

public static void main(String[] args) {

    demo1 demo1 = new demo1();

    new Thread(()->{

        demo1.waitMethod();

    }).start();

    try {

        Thread.sleep(2000);

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

    demo1.signalMethod();

}

}

运行结果:

Thread-0等待了...1549450097987

main被唤醒了...1549450099988

2 使用多个Condition实现,通知部分线程

接下来就是重头戏了Condition控制通知指定的线程醒来



/*

* 使用多个Condition, 唤醒指定的线程

* */

public class demo2 {

private Lock lock = new ReentrantLock();

private Condition conditionA = lock.newCondition();

private Condition conditionB = lock.newCondition();

public void waitA(){

try{

 lock.lock();

 System.out.println(Thread.currentThread().getName()+"等待了..."+System.currentTimeMillis());

 try {

     conditionA.await();

     System.out.println(Thread.currentThread().getName()+"await之后的代码..."+System.currentTimeMillis());

 } catch (InterruptedException e) {

     e.printStackTrace();

 }

}finally {

 lock.unlock();

}

}

public void waitB(){

try{

    lock.lock();

    System.out.println(Thread.currentThread().getName()+"等待了..."+System.currentTimeMillis());

    try {

        conditionB.await();

        System.out.println(Thread.currentThread().getName()+"await之后的代码..."+System.currentTimeMillis());

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

}finally {

    lock.unlock();

}

}

public void signalAALL(){

try{

 lock.lock();

 conditionA.signalAll();

 System.out.println(Thread.currentThread().getName()+" 执行唤醒操作. ."+System.currentTimeMillis());

}finally {

 lock.unlock();

}

}

public void signalBBLL(){

try{

    lock.lock();

    System.out.println(Thread.currentThread().getName()+"  被唤醒了.."+System.currentTimeMillis());

    conditionB.signalAll();

}finally {

    lock.unlock();

}

}

public static void main(String[] args) {

demo2 demo2 = new demo2();

ExecutorService executorService = Executors.newCachedThreadPool();

  executorService.execute(new Runnable() {

        @Override

        public void run() {

         demo2.waitA();

        // demo2.waitB();

        }

    });

try {

    Thread.sleep(2000);

} catch (InterruptedException e) {

    e.printStackTrace();

}

demo2.signalAALL();

System.out.println("mian 线程结束...");

}

}

结果:

pool-1-thread-1等待了...1549459953814

main 执行唤醒操作. .1549459955805

mian 线程结束...

pool-1-thread-1await之后的代码...1549459955805

通过结果可以看到,ReentrantLock对象,可以唤醒指定种类的线程,使用个Condition让线程等待,就用哪个Condition去把它唤醒

公平锁与非公平锁

Lock锁分为公平锁和非公平锁,所谓公平锁,就是表示线程获取锁的顺序,是按照线程加锁的顺序来实现的,也就是FIFO的顺序先进先出的顺序,而非公平锁描述的则是一种锁的随机抢占机制,还可能会导致一些线程根本抢不着锁而被饿死,结果就是不公平了

ReentrantLock支持公平锁

ReentrantLock()

创建一个 ReentrantLock 的实例。

构造方法名	简介
ReentrantLock(boolean fair)	创建一个具有给定公平策略的 ReentrantLock。

ReentrantLock几组常用API

第一组:

方法名	作用
int getHoldCount()	查询当前线程保存此锁的个数,(执行lock.lock()的次数),即重入的次数
int getQueueLength()	返回**正在等待获取此锁(调用该方法的锁)的线程的个数,比如有五条线程已经准备就绪了,其中一条线程首先执行lock.await()方法,紧接着调用该方法,获取到的返回值为4,说明有四条线程正在等待此lock
int getWaitQueueLength(Condition condition)	返回正在等待和此锁相关的condition的线程数

第二组:

方法名	作用
boolean hasQueuedThread(Thread thread)	判断当前线程是否正在等到获取到此锁
boolean hasQueuedThreads()	在所有的线程中查询,是否有线程正在等待此所的锁定
boolean hasWaiters(Condition condition)	判断是否有线程正在等待和此condition相关的条件

第三组

方法名	作用
boolean isFair()	判断此锁是不是公平的
boolean isHeldByCurrentThread()	判断当前线程是否拿到了锁
boolean isLocked()	判断此锁是否由任意线程保持

第四组

lock()与lockInterruptibly()

假如出现下面几步,我们这两种加锁方法,会有什么反应?,第一: 线程A启动,使用lock()加锁,第二步: CPU的执行权被线程B抢到,且线程B使用interrupted()方法给线程A打上中断的标记..第三步: 线程A继续执行

使用lock()加锁,假如我们没有使用isInterrupted()判断的话,代码会按照原来的顺序依次全部执行,没有异常,线程AB正常结束
使用lockInterruptibly()加锁,线程A被中断后,会调用lockInterruptibly()报异常,进入catch代码块

tryLock()与Lock()

boolean tryLock()与void lock() 前者是有返回值的,两者都能去获取锁,而tryLock()直意尝试获取锁,有就拿,没有算了,它多了一步判断,它在调用时,会去判断此锁是否被其他线程锁定,如果没有,则获取,并返回ture

if(lock.tryLock()){

    //do something 1 ...

}else{

    //do something 2...

}

可以看到,使用tryLock(),不至于当前线程被阻塞住

方法名	作用
boolean tryLock(Long timeout,TimeUnit unit)	如果在给定的等待时间内,锁没有被其他线程拿到,并且当前线程也没有被中断,获取锁

await()和awaitUninterrupted()

当线程A await() 线程B给线程A打上中断的标记

1.中断 2,抛出中断异常 3. 进入catch块

当线程A awaitUninterrupted() 线程B给线程A打上中断的标记

1.中断

boolean awaitUtil(Date deadLine);

出现一下几种情况,线程被唤醒

等待的时间结束
在等待.被中断的过程被提前唤醒
被中断

读写锁(排它锁,共享锁)

在一个不需要操作实例变量的方法中,完全可以使用读写锁来提升该方法的代码运行速度

读操作相关的锁是共享锁,写操作相关的锁为排他锁

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

读读共享 lock.readLock().lock();
写写互斥 lock.writeLock().lock();
读写互斥

获取读写锁

    public void read() {

        lock.readLock().lock();

        System.out.println("获取到了读锁" + Thread.currentThread().getName() + "  " + System.currentTimeMillis());

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            lock.readLock().unlock();

        }

    }

    public void write(){

        try {

            lock.writeLock().lock();

            System.out.println(""+Thread.currentThread().getName()+"  " +System.currentTimeMillis());

            Thread.sleep(2000);

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            lock.writeLock().unlock();

        }

    }

创建四条线程测试

获取到了读锁Thread-0  1548851348805

获取到了读锁Thread-1  1548851348805

Thread-2  1548851350806

Thread-3  1548851352806

JDK8新增StampedLock对ReentrantReadWriteLock进行增强

stamped:贴上邮票的; 盖上邮戳的,拿到锁之后会返回给我们一个票据,根据这个Stamp的值判断是在读的时候发生了写,还是在写的时候发生了读操作

解决的问题:

在高并发的情况下,读操作的次数远远大于写操作,,因为读写互斥,写操作可能就会出现饥饿的情况,一直抢占不到cpu的资源

解决方法:

当然可以使用公平的ReadWriteLock,但是依然有性能问题
StampedLock的乐观锁实现了读写共享提升了!

StampedLock里面有两种锁

乐观锁:

读锁并不会阻塞写锁

 public long tryOptimisticRead() {...}

悲观锁:

读写互斥,和ReentrantReadWriteLock实现相同的功能

API:

独占的获取写锁,若锁被其他线程获取到,则阻塞,注意它是相对于ReentrantReadWriteLock来讲,它是有返回值的,返回值的作用:

释放锁(unlock的需要参数)
进行锁的转换

   /**

     * Exclusively acquires the lock, blocking if necessary

     * until available.

     *

     * @return a stamp that can be used to unlock or convert mode

     */

    public long writeLock() {

        long s, next;  // bypass acquireWrite in fully unlocked case only

        return ((((s = state) & ABITS) == 0L &&

                 U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?

                next : acquireWrite(false, 0L));

    }



    //一旦写锁可用立即获取,返回值可以用作释放锁或被锁的转换使用, 0表示没有获取到锁

     /**

     * Exclusively acquires the lock if it is immediately available.

     *

     * @return a stamp that can be used to unlock or convert mode,

     * or zero if the lock is not available

     */

    public long tryWriteLock() {

        long s, next;

        return ((((s = state) & ABITS) == 0L &&

                 U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?

                next : 0L);

    }

    //延迟获取锁

         /**

     * Exclusively acquires the lock if it is available within the

     * given time and the current thread has not been interrupted.

     * Behavior under timeout and interruption matches that specified

     * for method {@link Lock#tryLock(long,TimeUnit)}.

     *

     * @param time the maximum time to wait for the lock

     * @param unit the time unit of the {@code time} argument

     * @return a stamp that can be used to unlock or convert mode,

     * or zero if the lock is not available

     * @throws InterruptedException if the current thread is interrupted

     * before acquiring the lock

     */

    public long tryWriteLock(long time, TimeUnit unit)

    ...

    // 非独占的获取读锁

      /**

     * Non-exclusively acquires the lock, blocking if necessary

     * until available.

     *

     * @return a stamp that can be used to unlock or convert mode

     */

    public long readLock() {

        long s = state, next;  // bypass acquireRead on common uncontended case

        return ((whead == wtail && (s & ABITS) < RFULL &&

                 U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?

                next : acquireRead(false, 0L));

    }

    // 一旦锁可用,立即非独占的获取读锁

    /**

     * Non-exclusively acquires the lock if it is immediately available.

     *

     * @return a stamp that can be used to unlock or convert mode,

     * or zero if the lock is not available

     */

    public long tryReadLock() {

        for (;;) {

            long s, m, next;

            if ((m = (s = state) & ABITS) == WBIT)

                return 0L;

            else if (m < RFULL) {

                if (U.compareAndSwapLong(this, STATE, s, next = s + RUNIT))

                    return next;

            }

            else if ((next = tryIncReaderOverflow(s)) != 0L)

                return next;

        }

    }

乐观锁!!!它获取到的锁,读写锁非互斥

返回一个标记,这个标记过一会用去校验, 如果锁是排它锁,返回零



    /**

     * Returns a stamp that can later be validated, or zero

     * if exclusively locked.

     *

     * @return a stamp, or zero if exclusively locked

     */

    public long tryOptimisticRead() {

        long s;

        return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;

    }

校验,如果锁还没被任何线程获取,获取被持有当前stamp的线程获取返回true , 如果 stamp为0,返回false

     /**

     * Returns true if the lock has not been exclusively acquired

     * since issuance of the given stamp. Always returns false if the

     * stamp is zero. Always returns true if the stamp represents a

     * currently held lock. Invoking this method with a value not

     * obtained from {@link #tryOptimisticRead} or a locking method

     * for this lock has no defined effect or result.

     *

     * @param stamp a stamp

     * @return {@code true} if the lock has not been exclusively acquired

     * since issuance of the given stamp; else false

     */

    public boolean validate(long stamp) {

        U.loadFence();

        return (stamp & SBITS) == (state & SBITS);

    }

锁的释放



    /**

     * If the lock state matches the given stamp, releases the

     * exclusive lock.

     *

     * @param stamp a stamp returned by a write-lock operation

     * @throws IllegalMonitorStateException if the stamp does

     * not match the current state of this lock

     */

    public void unlockWrite(long stamp) {

        WNode h;

        if (state != stamp || (stamp & WBIT) == 0L)

            throw new IllegalMonitorStateException();

        state = (stamp += WBIT) == 0L ? ORIGIN : stamp;

        if ((h = whead) != null && h.status != 0)

            release(h);

    }

  //释放任意匹配成功的锁

    /**

     * If the lock state matches the given stamp, releases the

     * corresponding mode of the lock.

     *

     * @param stamp a stamp returned by a lock operation

     * @throws IllegalMonitorStateException if the stamp does

     * not match the current state of this lock

     */

    public void unlock(long stamp) {

读,写锁之间的转换

     public long tryConvertToWriteLock(long stamp) {

     ..}

      public long tryConvertToWriteLock(long stamp) {

    ..}

    //释放读锁

    public void unlockRead(long stamp) {..}

    //释放写锁

    public void unlockWrite(long stamp) {..}

简单使用后

/*

* StampedLock的简单使用

* */

public class StampedLock01 {

private  int balance;

StampedLock stamptedLock = new StampedLock();

//悲观读

public void read(){

    long s = stamptedLock.readLock();

try{

    try {

        System.out.println("拿到读锁"+Thread.currentThread().getName()+System.currentTimeMillis());

        Thread.sleep(2000);

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

}finally {

    stamptedLock.unlockRead(s);

}

}

// 乐观锁

public void OptimismRead(){

    //获取乐观锁,拿到 标记

    long stm = stamptedLock.tryOptimisticRead();

    try {

        System.out.println("一开始读取到的balance=="+balance);

        //方便测试     睡一会

        Thread.sleep(200);

        // 在读的时候,可能会出现现写操作-- 判断

        if(!stamptedLock.validate(stm)){  //1 锁空闲可用  2 拥有当前stm的线程获取到锁,返回true  其他返回false

            //重新读取

            long l = stamptedLock.readLock();

            System.out.println("乐观锁中发现了在读时,发现写操作,重新读结果为:  "+balance);

            // 更新标记, 用于锁的释放

            stm=l;

        }

    }catch (Exception e){

        e.printStackTrace();

    }finally {

        //释放锁

        stamptedLock.unlockRead(stm);

    }

}

// 带条件的读写锁

public void MyConditionReadWriteLock(int v){

    //判断balance是否符合更新的条件

    long stm = stamptedLock.readLock();

    try{

        // 为什么不会if  而用while

        while(stm>0){

            //转换成写锁;

            long s1 = stamptedLock.tryConvertToWriteLock(stm);

            if (s1!=0){// 成功转换

                balance+=v;

                System.out.println("进行写操作:  balance=="+balance+99);

                stm=s1;

                break;

            }else{  //没有转换成功

                //释放读锁

                stamptedLock.unlockRead(stm);

                // 获取写

                long s2 = stamptedLock.writeLock();

                stm=s2;

                System.out.println("手动获取写锁...");

            }

        }

    }finally {

        stamptedLock.unlock(stm);

    }

}

//独占的写

public void write(int v){

        long stamp = stamptedLock.writeLock();

        try{

            balance+=v;

            System.out.println("进行写的操作...结果:  "+balance+"  "+Thread.currentThread().getName()+"  "+"write中的标记为:"+stamp);

            Thread.sleep(2000);

        }catch (Exception e){

            e.printStackTrace();

        }

        finally {

            stamptedLock.unlockWrite(stamp);

        }

}

public static void main(String[] args) {

    StampedLock01 stampedLock01 = new StampedLock01();

    //测试普通的read  // 测试成功 异步执行

    //测试独占的写  成功

/*       new Thread(()->{

        // 乐观读

        stampedLock01.OptimismRead();

    }).start();

    new Thread(()->{

        stampedLock01.write(3);

    }).start();

*/

    new Thread(()->{

        stampedLock01.MyConditionReadWriteLock(1);

    }).start();

}

}

最后提一下 > 如何选择大名鼎鼎的AQS最有名的实现类ReentrantLock和synchronized这个JVM提供的锁,一开始synchronized是一个笨重的重量级锁,但是jdk1.5之后,进行了偏向锁,轻量级锁的优化,使它的性能和ReentrantLock擦不多了,于是没有特殊的要求,官方推荐使用synchronized

什么情况下使用ReentrantLock呢?

使用它特有的公平锁
使用它的Condition类,分组唤醒指定的线程
提供了能够中断正在等待锁的线程的机制,lock.lockInterrupted()