java中的ReetrantLock与锁作用

发布时间:2021-07-09 09:06:50 作者:chen
来源:亿速云 阅读:132

本篇内容介绍了“java中的ReetrantLock与锁作用”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

java主要分两类锁,一种是synchronized关键字修饰的锁,另一种是J.U.C.提供的锁。J.U.C里核心锁就是ReentrantLock

ReentrantLock(可重入锁)和synchronized区别

ReentrantLock独有的功能:

使用场景

如果需要ReentrantLock独有的功能时可以使用ReentrantLock。其他情况下可以根据性能来选择使用ReentrantLock还是synchronized。

synchronized能做的事情ReentrantLock都能做,而ReentrantLock能做的synchronize却不一定能做,性能方面ReentrantLock也不必synchronize差。那么我们要不要抛弃synchronize?当然是否定的,java.util.current.lock下的类一般用于高级用户和高级情况的工具,一般来说除非对lock的某个高级特性有明确的需要或者有明确的证据标明在特定的情况下,同步已经成为可伸缩性的瓶颈的时候,否则建议继续使用synchronized。

即使对于这些高级的锁定类来说,synchronized仍然有一些优势,比如在使用synchronized时候不可能忘记释放锁,在退出synchronize块时,jvm会为你做这些事情,否则一旦忘记释放锁而产生死锁很难查出原因,因此不建议初级开发人员使用lock。

另外当jvm用synchronized来管理锁定请求和释放时,jvm在生成线程转储时,能够包括锁定信息,这些对调试非常有价值,因为他们能标识死锁或者其他异常行为的来源。而lock类只是一个普通的类,jvm不知道具体哪个线程拥有lock对象,而且几乎每个开发人员都熟悉synchronized,可以在jvm的所有版本中工作,在大部分使用场景下都可以使用synchronized来实现。 

@Slf4j
public class LockExample2 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private final static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i = 0; i < clientTotal; i++) {
            executorService.execute(() ->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {

                    log.error("exception", e);
                }
                countDownLatch.countDown();

            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    public static void add() {
        lock.lock();
        try{
            count++;
        }finally {
            lock.unlock();
        }
    }

}

ReentrantReadWriteLock

@Slf4j
public class LockExample3 {

    private final Map<String, Data> map = new TreeMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    public Data get (String key){
        readLock.lock();
        try{
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }
    public Set<String> getAllKeys() {
        readLock.lock();
        try{
            return map.keySet();
        }finally {
            readLock.unlock();
        }
    }
    public Data put(String key, Data value) {
        writeLock.lock();
        try {
            return map.put(key, value);
        }finally {
            writeLock.unlock();
        }
    }
    class Data {

    }

}

write.lock()保证在没有读锁的时候才进行写入操作,对数据同步做的更多一些,使用悲观读取,也就是说如果有写入锁时,坚决不允许有读锁还保持着,保证了在写的时候其他事情已经做完了。这样就会有一个问题,在读取情况较多而写入很少的时候,调用上面例子中的put方法就会遭遇饥饿(写锁一直想执行,但是读锁一直在,导致写锁永远无法执行,一直在等待)

StampedLock

stampedLock控制锁有三种模式,分别是写、读、乐观读。StampedLock由版本和模式两个模块组成,返回一个数字(票据stamp),用相应的锁状态来表示并控制相应的访问,数字0表示没有写锁被访问。读锁分为乐观锁和悲观锁,乐观锁是当读的情况很多,写的情况很少,可以认为读写同时发生的几率很小,因此不悲观的使用完全悲观的锁定,程序可以读取数据之后是否得到写入执行的变更,再采取后续的措施,这一个小小的改进,可以大幅度提高程序的吞吐量。

@Slf4j
public class LockExample4 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private final static StampedLock lock = new StampedLock();

    public static void main(String[] args) throws InterruptedException {
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i = 0; i < clientTotal; i++) {
            executorService.execute(() ->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {

                    log.error("exception", e);
                }
                countDownLatch.countDown();

            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    public static void add() {
        long stamp = lock.writeLock();
        try{
            count++;
        }finally {
            lock.unlock(stamp);
        }
    }

}

总结

synchronized:是在jvm层面实现的,不但可以通过一些监控工具监控synchronized的锁定,而且在代码执行时出现异常JVM也可以释放锁定,jvm会自动加锁与解锁。

ReentrantLock、ReentrantReadWriteLock、StampedLock:都是对象层面的锁定,要保证锁一定会被释放,一定要把unlock操作放在finally中才安全一些。StampedLock对吞度量有巨大的改进,特别是在读线程很多的场景下。

那么我们该如何选择使用哪个锁?

  1. 当只有少量的竞争者时,synchronized是一个很好的通用锁实现。

  2. 竞争者较多,而且竞争者的增长趋势可以预估,ReentrantLock是一个很好的通用锁实现。

我们在用锁时不是看哪个锁高级用哪个。适合自己使用场景的才是最关键的。 

需要注意的是synchronized不会引发死锁,jvm会自动解锁。而其他的Lock一旦使用不当会造成死锁,有可能会在一些情况下未执行unlock操作。

“java中的ReetrantLock与锁作用”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站,小编将为大家输出更多高质量的实用文章!

推荐阅读:
  1. 带你快速了解Java锁中的公平锁与非公平锁
  2. Java中可重入锁的作用有哪些

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

java

上一篇:asp.net Mvc4如何使用ajax结合分页插件实现无刷新分页

下一篇:windows上怎么查看占用文件或文件夹的进程ID

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》