怎么进行Lock总结

今天就跟大家聊聊有关怎么进行Lock总结，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。

Lock在我们日常研发中经常会使用到，比如ReenTrantLock，ReentrantReadWriteLock，StampedLock (JDK1.8新增)，下面就详细介绍一下它们的使用方法。

ReenTrantLock

ReenTrantLock支持公平锁和非公平锁,也是独占锁,下面来说一下ReenTrantLock下的方法和使用。

lock： 获取阻塞锁。

// 默认是费公平锁，可自定，在参数中增加 true-公平 false-非公平
ReenTrantLock lockObjcet = new ReenTrantLock();
try {
  // 获取锁 ，如果获取不到则阻塞线程
  lockObjcet.lock();
  // 同步代码块
} catch (Exception e) {

} finally {
  // 释放锁
  lockObjcet.unLock();
}

**tryLock：**获取非阻塞锁，如果无法获取到锁，返回false，获取到了返回true。

ReenTrantLock lock = new ReenTrantLock();
if (lock.tryLock()) {
  // 获取到了锁
} else {
  // 没有获取到锁
}

**tryLock(time)：**获取非阻塞超时锁，在time时间内如果获取到了锁，返回true，获取不到锁返回false。

ReenTrantLock lock = new ReenTrantLock();
// 获取锁，如果在指定时间内还未获得，则返回false
if (lock.tryLock(100)) {
  // 获取到了锁
} else {
  // 没有获取到锁
}

lockInterruptibly()： 获取可中断锁，和lock区别就是在获取锁的过程中可以中断线程。
unlock()： 解锁
boolean isHeldByCurrentThread()： 判断锁是否是当前线程持有，是返回true，不是返回false。
boolean isLocked()： 判断锁是否被获取或占用。
boolean isFair()： 是否是公平锁，是返回true，不是返回false。
Thread getOwner()： 获取当前锁的拥有者，如果有拥有者则返回拥有者，如果没有返回null。
boolean hasQueuedThreads()： 判断是否有等待线程，如果有则返回true，反之false。
boolean hasQueuedThread(Thread thread)： 判断入参的线程是否存在于等待队列中，如果存在则返回true，反之false。
int getQueueLength()： 获取等待队列中线程总数。
Collection<Thread> getQueuedThreads()： 获取等待队列中的所有线程。
boolean hasWaiters(Condition condition)： 否有线程在与此锁关联的给定条件上等待，有返回true 反之 false。
int getWaitQueueLength(Condition condition)： 获取被参数条件等待的线程总数。
Collection<Thread> getWaitingThreads(Condition condition)： 获取当前锁的条件等待的所有线程.

ReentrantReadWriteLock

读写锁： 读锁可以多线程一起获取，写锁只有一个线程可以获取，读写锁支持公平锁和非公平锁，支持重入锁。

读锁： 可以被多个线程共同获取锁，同时进入代码块。

写锁： 只允许一个线程获取，如果当前线程获取到写锁后，发现有线程获取了读锁，并且不是当前线程，这时当前线程就进入等待状态。

代码示例：

// 读写锁
private  ReadWriteLock rw = new ReentrantReadWriteLock();
// 读锁 共享锁
private  Lock r = rw.readLock();
// 写锁 排它锁
private  Lock w = rw.writeLock();

WriteLock
ReadLock

lock()： 加锁。
unlock()： 解锁。

lock()： 写锁为独占锁，当线程A获取到了写锁时任何线程都不能获取到读锁和写锁，如果线程A获取到了写锁，但是读锁已经被线程B获取并且未释放，这时就需要将线程A状态改为等待，等待线程B释放了写锁再继续执行。
unlock()： 解锁。

StampedLock (JDK1.8新增)

StampedLock：读写锁，但是StampedLock比ReenTrantReadWriteLock更块,但是StampedLock 用于 乐观读锁，悲观读 锁，和写锁，StampedLock不支持重入锁，StampedLock 的悲观读锁、写锁都不支持条件变量。

代码示例：

/**
 * @Auther: lantao
 * @Date: 2019-05-05 17:55
 * @Company: 随行付支付有限公司
 * @maill: lan_tao@suixingpay.com
 * @Description: TODO
 */
public class StampedLockTest {

    static StampedLock s =new StampedLock();

    public static void main(String[] args) {

        // 悲观读
        long l = s.readLock();

        // 释放悲观读
        s.unlockRead(l);


        // 悲观写
        long l1 = s.writeLock();

        // 释放悲观写
        s.unlockWrite(l1);


        // 乐观读 升级 悲观读
        long l2 = s.tryOptimisticRead();

        //验证是否被修改 如果返回false 会释放 l2，所以后续直接释放l3即可
        if (!s.validate(l2)){
            // 升级悲观读
            long l3 = s.readLock();
            s.unlockRead(l3);
        }
    }
}

tryOptimisticRead： 乐观读。
readLock： 悲观读。
writeLock： 悲观写。

Conditionn

Condition： Lock 的条件 ,其实初始化的是ConditionObject， ConditionObject是Condition的实现，singal和signlAll的时候需要在获取锁后。**

代码示例：

/**
 * @Auther: lantao
 * @Date: 2019-04-15 14:49
 * @Company: 随行付支付有限公司
 * @maill: lan_tao@suixingpay.com
 * @Description: Condition 条件 有 singal signalAll 和 await 方法 和Object 的 notify notifyAll 和 wait 是一个意思同样会释放锁  执行singal和notify的时候也需要在等待获取锁
 */
public class LockCondition {

    public static ReentrantLock lock = new ReentrantLock();

    public static Condition a = lock.newCondition();

    public static Condition b = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName());
                a.await();

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

                b.await();

                System.out.println(Thread.currentThread().getName() +  " 的 b conndition 被唤醒了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        };

        Runnable runnable1 = () -> {
            try {
                lock.lock();
                System.out.println("线程" +Thread.currentThread().getName() + " 开始执行a condition sinalAll");
                a.signalAll();

            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        };

        Runnable runnable2 = () -> {
            try {
                lock.lock();
                System.out.println("线程" +Thread.currentThread().getName() + " 开始执行b condition sinalAll");
                b.signalAll();

            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        };

        new Thread(runnable,"Thread1").start();
        new Thread(runnable,"Thread2").start();
        Thread.sleep(100);
        new Thread(runnable1,"Thread3").start();
        Thread.sleep(100);
        new Thread(runnable2,"Thread4").start();
    }
}

// 执行结果
Thread1
Thread2
线程Thread3 开始执行a condition sinalAll
Thread1 的 a conndition 被唤醒了
Thread2 的 a conndition 被唤醒了
线程Thread4 开始执行b condition sinalAll
Thread1 的 b conndition 被唤醒了
Thread2 的 b conndition 被唤醒了

看完上述内容，你们对怎么进行Lock总结有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注行业资讯频道，感谢大家的支持。

ReenTrantLock

ReentrantReadWriteLock

StampedLock (JDK1.8新增)

Conditionn

相关推荐