JAVA-JUC-ReentrantLock

ReentrantLock 与synchronized区别

1.可重入性

 两者的区别不大 都是同一个线程进入一次锁的计数器自增1要等到锁的计数器下降为0时才能释放锁

2.锁的实现

synchronized关键字是通过JVM实现的,ReentrantLock是通过JDK实现的

3.性能区别

synchronize优化后区别不大,官方推荐使用synchronized 因为使用方便

3.功能区别

synchronized使用起来方便通过JVM实现而ReentrantLock需要手动声明/加锁/释放锁,手动操作就又可能造成死锁(忘记释放),但是锁的细粒度和灵活度方面ReentrantLock优于synchronized

4.ReentrantLock独有的功能

1.可指定是公平锁还是非公平锁 synchronized只能是非公平锁(公平锁是指:先等待的线程先获得锁)
2.提供了一个condition类,可以分组唤醒需要唤醒的线程
3.提供能够中断等待锁的线程机制,lock.lockInterruptibly()

5.使用方式

package com.common.example.JavaCore.juc;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Auther: Gz.
 * @Date: 2019/2/25 14:36
 * @Description:J.U.C 包下 ReetrantLock使用样例
 */
@Slf4j
public class LockExample {

  private static final int threadCount = 200;

  //并发数
  private static final int clietnTotal = 5000;

  //初始化锁
  private final static  Lock lock = new ReentrantLock();

  //初始化计数
  private static int count = 0;

  public static void main(String[] args) throws InterruptedException {

    ExecutorService executorService = Executors.newCachedThreadPool();

    final CountDownLatch countDownLatch = new CountDownLatch(clietnTotal);

    final Semaphore semaphore = new Semaphore(threadCount);
    //循环
    for(int i=0; i<clietnTotal;i++){
      //线程池调用
      executorService.execute(()->{
        try {
          //业务逻辑方法
          semaphore.acquire();
          add();
          semaphore.release();
        } catch (InterruptedException e) {
          log.error("exception",e);
        }finally {
          //执行完业务逻辑一定要执行 countDown方法 来-1
          //如果未调用则无法执行 下方的await()方法
          //内部使用CAS算法 调用CPU级别指令 安全高效
          countDownLatch.countDown();
        }
      });
    }
    countDownLatch.await();
    log.info("count={}",count);
    executorService.shutdown();

  }

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



}