J.U.C之Lock ReentrantLock & 锁

乌鲁木齐001号程序员

于 2019-03-29 20:30:00 发布

阅读量100

点赞数

本文链接：https://blog.csdn.net/weixin_33669968/article/details/88904905

版权

Java中的锁

Java中的锁大体分2类；

synchronized修饰的锁；
J.U.C中提供的锁，其中核心的就是ReentrantLock；

ReentrantLock （可重入锁）和synchronized区别

可重入性
锁的实现
- synchronized依赖于JVM实现，好比操作系统控制实现，很难看到源码；
- ReentrantLock是JDK实现的，好比用户自己敲代码实现，源码可以直接读；
性能的区别
- synchronized在优化以前，其性能比ReentrantLock差很多；自从synchronized引入偏向锁，轻量级锁也就是自旋锁后，他们两者的性能就差不多了；在两种方法都可用的情况下，官方更建议使用synchronized，因为写法更容易；
功能的区别
- 便利性：synchronized的使用更方便简洁，通过编译器实现加锁和释放；ReentrantLock需要手工声明来加锁和释放锁，最好在finally中释放锁，以避免死锁；
- 锁的细粒度 & 灵活度：ReentrantLock由于synchronized；

ReentrantLock独有的功能

可指定是公平锁还是非公平锁，synchronized只能是非公平锁，公平锁指的是先等待的线程先获得锁；
提供了一个Condition类，可以分组唤醒需要唤醒的线程；
提供能够中段等待锁的线程的机制，lock.lockInterruptibly()，ReentrantLock的实现是自旋锁，通过循环调用CAS操作实现加锁，其性能好也是因为避免进入内核态的阻塞状态，避免线程进入内核的阻塞状态是分析和理解锁设计的关键钥匙；

当需要实现ReentrantLock这3个独有的功能的时候，是必须使用ReentrantLock的

synchronized的优势

不会忘记释放锁，退出synchronized块的时候，JVM会做这件事；
当JVM用synchronized管理锁定请求和释放时，JVM在生成线程转储时，能后包括锁定信息，这些对调试非常有价值，它们能标识死锁或者其他异常行为的来源；而Lock类只是普通的类，JVM不知道具体哪个线程拥有Lock对象；

ReentrantLock示例

import com.example.concurrency.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
@ThreadSafe
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 Exception {
        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 (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

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

输出：