Java中的常见锁(公平和非公平锁、可重入锁和不可重入锁、自旋锁、独占锁和共享锁)
公平和非公平锁
- 公平锁:是指多个线程按照申请的顺序来获取值。在并发环境中,每一个线程在获取锁时会先查看此锁维护的等待队列,如果为空,或者当前线程是等待队列的第一个就占有锁,否者就会加入到等待队列中,以后会按照 FIFO 的规则获取锁
- 非公平锁:是指多个线程获取值的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取锁。在并发环境中一上来就尝试占有锁,如果失败再进行排队,可能会造成优先级翻转或者饥饿现象
// 常用的ReentrantLock无参构造默认是非公平锁 /**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
} /**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
可重入锁和不可重入锁
- 可重入锁:指的是同一个线程外层函数获得锁之后,内层仍然能获取到该锁,在同一个线程在外层方法获取锁的时候,在进入内层方法或会自动获取该锁
- 不可重入锁: 即若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞
/**
* 可重入锁实现
*/
public class ReentrantLock {
boolean isLocked = false;
Thread lockedBy = null;
int lockedCount = 0;
public synchronized void lock() throws InterruptedException {
Thread thread = Thread.currentThread();
while (isLocked && lockedBy != thread) {
wait();
}
isLocked = true;
lockedCount++;
lockedBy = thread;
} public synchronized void unlock() {
if (Thread.currentThread() == lockedBy) {
lockedCount--;
if (lockedCount == 0) {
isLocked = false;
notify();
}
}
}
} /**
* 测试类
*/
public class Count {
ReentrantLock lock = new ReentrantLock();
public void print() throws InterruptedException{
lock.lock();
doAdd();
lock.unlock();
} private void doAdd() throws InterruptedException {
lock.lock();
// do something
System.out.println("ReentrantLock");
lock.unlock();
} /**
* 发现可以输出 ReentrantLock,我们设计两个线程调用 print() 方法,第一个线程调用 print() 方法获取锁,进入 lock() 方法,由于初始 lockedBy 是 null,所以不会进入 while 而挂起当前线程,而是是增量 lockedCount 并记录 lockBy 为第一个线程。接着第一个线程进入 doAdd() 方法,由于同一进程,所以不会进入 while 而挂起,接着增量 lockedCount,当第二个线程尝试lock,由于 isLocked=true,所以他不会获取该锁,直到第一个线程调用两次 unlock() 将 lockCount 递减为0,才将标记为 isLocked 设置为 false
*/
public static void main(String[] args) throws InterruptedException {
Count count = new Count();
count.print();
}
}
/**
* 不可重入锁实现
*/
public class NotReentrantLock {
private boolean isLocked = false;
public synchronized void lock() throws InterruptedException {
while (isLocked) {
wait();
}
isLocked = true;
}
public synchronized void unlock() {
isLocked = false;
notify();
}
} /**
* 测试
*/
public class Count {
NotReentrantLock lock = new NotReentrantLock();
public void print() throws InterruptedException{
lock.lock();
doAdd();
lock.unlock();
} private void doAdd() throws InterruptedException {
lock.lock();
// do something
lock.unlock();
} /**
* 当前线程执行print()方法首先获取lock,接下来执行doAdd()方法就无法执行doAdd()中的逻辑,必须先释放锁。这个例子很好的说明了不可重入锁
*/
public static void main(String[] args) throws InterruptedException {
Count count = new Count();
count.print();
}
}
synchronized 和 ReentrantLock 都是可重入锁
自旋锁
概念:是指定尝试获取锁的线程不会立即堵塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上线文切换的消耗,缺点就是循环会消耗 CPU
/**
* 自选锁实现
*/
public class SpinLock {
private AtomicReference<Thread> atomicReference = new AtomicReference<>();
private void lock () {
System.out.println(Thread.currentThread() + " coming...");
while (!atomicReference.compareAndSet(null, Thread.currentThread())) {
// loop
}
} private void unlock() {
Thread thread = Thread.currentThread();
atomicReference.compareAndSet(thread, null);
System.out.println(thread + " unlock...");
} public static void main(String[] args) throws InterruptedException {
SpinLock spinLock = new SpinLock();
new Thread(() -> {
spinLock.lock();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hahaha");
spinLock.unlock(); }).start(); Thread.sleep(1); new Thread(() -> {
spinLock.lock();
System.out.println("hehehe");
spinLock.unlock();
}).start();
}
} /**
* 输出内容:
* Thread[Thread-0,5,main] coming...
* Thread[Thread-1,5,main] coming...
* hahaha
* Thread[Thread-0,5,main] unlock...
* hehehe
* Thread[Thread-1,5,main] unlock...
*
* 获取锁的时候,如果原子引用为空就获取锁,不为空表示有人获取了锁,就循环等待,借鉴CAS底层实现
*/
独占锁(写锁)/共享锁(读锁)
- 独占锁:指该锁一次只能被一个线程持有
- 共享锁:该锁可以被多个线程持有
对于 ReentrantLock 和 synchronized 都是独占锁;对于 ReentrantReadWriteLock 其读锁是共享锁而写锁是独占锁。读锁的共享可保证并发读是非常高效的,读写、写读和写写的过程是互斥的
/**
* 读写锁的应用
*/
public class MyCache { private volatile Map<String, Object> map = new HashMap<>(); private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
WriteLock writeLock = lock.writeLock();
ReadLock readLock = lock.readLock(); /**
* 独占锁(写锁)
*/
public void put(String key, Object value) {
try {
writeLock.lock();
System.out.println(Thread.currentThread().getName() + " 正在写入...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + " 写入完成,写入结果是 " + value);
} finally {
writeLock.unlock();
}
} /**
* 共享锁(读锁)
*/
public void get(String key) {
try {
readLock.lock();
System.out.println(Thread.currentThread().getName() + " 正在读...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object res = map.get(key);
System.out.println(Thread.currentThread().getName() + " 读取完成,读取结果是 " + res);
} finally {
readLock.unlock();
}
}
} /**
* 测试代码
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache cache = new MyCache(); for (int i = 0; i < 5; i++) {
final int temp = i;
new Thread(() -> {
cache.put(temp + "", temp + "");
}).start();
} for (int i = 0; i < 5; i++) {
final int temp = i;
new Thread(() -> {
cache.get(temp + "");
}).start();
}
}
}
执行结果:
Thread-0 正在写入...
Thread-0 写入完成,写入结果是 0
Thread-1 正在写入...
Thread-1 写入完成,写入结果是 1
Thread-2 正在写入...
Thread-2 写入完成,写入结果是 2
Thread-3 正在写入...
Thread-3 写入完成,写入结果是 3
Thread-4 正在写入...
Thread-4 写入完成,写入结果是 4
Thread-5 正在读...
Thread-7 正在读...
Thread-8 正在读...
Thread-6 正在读...
Thread-9 正在读...
Thread-5 读取完成,读取结果是 0
Thread-7 读取完成,读取结果是 2
Thread-8 读取完成,读取结果是 3
Thread-6 读取完成,读取结果是 1
Thread-9 读取完成,读取结果是 4 能保证读写、写读和写写的过程是互斥的时候是独享的,读读的时候是共享的
Java中的常见锁(公平和非公平锁、可重入锁和不可重入锁、自旋锁、独占锁和共享锁)的更多相关文章
- Java多线程系列--“JUC锁”05之 非公平锁
概要 前面两章分析了"公平锁的获取和释放机制",这一章开始对“非公平锁”的获取锁/释放锁的过程进行分析.内容包括:参考代码获取非公平锁(基于JDK1.7.0_40)释放非公平锁(基 ...
- Java 中的静态嵌套类和非静态嵌套类
Java 中的静态嵌套类和非静态嵌套类 术语:嵌套类分为两类:静态嵌套类和非静态嵌套类.声明 static 的嵌套类称为静态嵌套类,非静态嵌套类也称为内部类. class OuterClass { p ...
- Java中请优先使用try-with-resources而非try-finally
Java中请优先使用try-with-resources而非try-finally Java库包含了很多需要手工调用close方法来关闭的资源.比如说InputStream.OutputStream及 ...
- Java中synchronized用在静态方法和非静态方法上面的区别
synchronized 修饰在 static方法和非static方法的区别 在Java中,synchronized是用来表示同步的,我们可以synchronized来修饰一个方法.也可以sync ...
- JAVA中字符串常见操作
String str1="hello,world";String str2="Hello,World"; 1.字符串的比较:例,System.out.print ...
- Java 中最常见的 5 个错误
在编程时,开发者经常会遭遇各式各样莫名错误.近日,Sushil Das 在 Geek On Java上列举了 Java 开发中常见的 5 个错误,与君共「免」. 原文链接:Top 5 Common M ...
- Java学习之道:Java中十个常见的违规编码
近期,我给Java项目做了一次代码清理工作.经过清理后,我发现一组常见的违规代码(指不规范的代码并不表示代码错误)反复出如今代码中.因此,我把常见的这些违规编码总结成一份列表,分享给大家以帮助Java ...
- Java中十个常见的违规编码
摘要:作者Veera Sundar在清理代码工作时发现一些常见的违规编码,因此,Veera Sundar把针对常见的一些违规编码总结成一份列表,以便帮助Java爱好者提高代码的质量和可维护性. 最近, ...
- java中各种常见的异常
一.各种常见的异常 在上一节中程序如果你注意留意,程序抛出的异常是:java.lang.ArithmeticException.这个异常是在lang包中已经定义的.在lang包中还定义了一些我们非常常 ...
随机推荐
- 你真的了解 get 和 post 的区别么
get 和 post 是两种最常用的 HTTP 请求方法,要说它们两个的区别,相必接触过 WEB 开发的人都能够说出一二. 如果我问你这个问题,你的内心充满了自信和喜悦.你可能已经写过无数个 GET ...
- pandas 数据类型转换及描述统计
处理数据的时候往往需要对原始数据进行类型转换和预览等操作,下面介绍常用的处理预览和数据转换方法 预览:例: import pandas as pdsec_weather = pd.read_table ...
- 使用log4j将数据流入flume
最近做了一个log抽取的项目,采用log4j+flume实现,在此分享记录一下. 准备 什么是flume? flume是一个提供高可用的,高可靠的,分布式的海量日志采集.聚合和传输的系统. flume ...
- SpringBoot启动注解源码流程学习总结
- e3mall商城的归纳总结2之认识dubbo、zookeeper
由于本项目用的是soa架构,因此必须需要两个系统之间进行通信,目前的解决办法有三种(本人认为) Webservice:效率不高基于soap协议.项目中不推荐使用. 使用restful形式的服务:htt ...
- vue前端获取env中的常量
process.env.常量名 如:process.env.MIX_APP_URL
- org.xml.sax.SAXParseException: The processing instruction target matching "[xX][mM][lL]" is not allowed(转)
xml文件不能被正确解析/The processing instruction target matching "[xX][mM][lL]" is not allowed. The ...
- 算法专题 | 10行代码实现的最短路算法——Bellman-ford与SPFA
今天是算法数据结构专题的第33篇文章,我们一起来聊聊最短路问题. 最短路问题也属于图论算法之一,解决的是在一张有向图当中点与点之间的最短距离问题.最短路算法有很多,比较常用的有bellman-ford ...
- HTML语言基本单词与css基本单词
DOCTYPE 文档 html 网页 head 头部 body 主体 title 题目 p 段落 color 颜色 style 样式 backgroun ...
- C# 发送邮件通知
web.config <!-- 配置发邮件:邮件访问登录地址--> <add key="HttpsUrl" value="http://localhos ...