首先要知道 Java 中的锁主要分两类锁 , 一种是 synchronize锁 , 另外一种就是 J.U.C中 提供的锁 , J.U.C里核心的锁是 ReentrantLock
ReentrantLock (可重入锁)与 synchronize 的区别
可重入性
ReentrantLock 字面意思就是 再进入 锁 , 所以称之为可重入锁 , synchronize 使用的锁也是可重入的. 它俩都是同一个线程进入一次锁的计数器就自增 1,所以要等到锁的计数器下降为 0 时才释放锁 .
锁的实现
synchronize 的锁是基于 JVM 来实现的 , ReentrantLock 是jdk 实现的. 通俗的来讲就是 操作系统来控制实现和用户编码实现的区别 .
性能区别
在 synchronize 关键字优化之前, 其性能比 ReentrantLock 差 , 但是优化过后 , 在两者都可以使用的情况下, 建议使用 synchronize, 主要是其写法比较容易
功能
synchronize 写起来更简洁 , 它是由编译器来实现锁的加锁和释放 , 而ReentrantLock 需要我们手工申明加锁和释放锁 , 为了避免手工忘记释放锁而造成死锁 , 所以建议在final里申明和释放锁.
-
ReentrantLock 独有的功能
- ReentrantLock可指定是公平锁还是非公平锁 , 公平锁就是先等待的线程先获得锁.有先来后到之说. 而synchronize是非公平锁
- 提供了一个 Condition 类 , 可以分组唤醒需要唤醒的线程 , 不像 synchronize要么随机唤醒一个线程 , 要么唤醒全部线程
- 提供能够中断等待锁的线程的机制 ,
import com.mmall.concurrency.annoations.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;
/**
* 实例说明 模拟并发 发送5000 个请求 , 每次最多200 个请求 ,
* 每次计数自增1 , 最后结果应该是5000
*/
@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();
}
}
}
控制台输入时正确的, 结果为 5000
