JAVA 各种锁机制
可重入锁
可重锁是指同一个线程,外层函数获取锁后,内层函数可以自动获取到锁。
java中synchronized和ReentrantLock都是可重入锁。
对于synchronized,其实现机制有jvm实现。
对于ReentrantLock,其继承自父类AQS,其父类AQS中维护了一个同步状态status来计数重入次数,status初始值为0。
当线程尝试获取锁时,可重入锁先尝试获取并更新status值,如果status == 0表示没有其他线程在执行同步代码,则把status置为1,当前线程开始执行。如果status != 0,则判断当前线程是否是获取到这个锁的线程,如果是的话执行status+1,且当前线程可以再次获取锁。而非可重入锁是直接去获取并尝试更新当前status的值,如果status != 0的话会导致其获取锁失败,当前线程阻塞。
释放锁时,可重入锁同样先获取当前status的值,在当前线程是持有锁的线程的前提下。如果status-1 == 0,则表示当前线程所有重复获取锁的操作都已经执行完毕,然后该线程才会真正释放锁。而非可重入锁则是在确定当前线程是持有锁的线程之后,直接将status置为0,将锁释放。
测试代码
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* 可重入锁
* 1 synchronized
* 2 ReentrantLock
*/
public class Main {
private ReentrantLock lock = new ReentrantLock();
private synchronized void get() {
System.out.println(Thread.currentThread().getName() + " invoke get() method");
set();
}
private synchronized void set() {
System.out.println(Thread.currentThread().getName() + " invoke set() method");
}
private void _get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " invoke _get() method");
_set();
} catch (Exception ignored) {
} finally {
lock.unlock();
}
}
private void _set(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " invoke _set() method");
} catch (Exception ignored) {
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Main main = new Main();
new Thread(main::get, "t1").start();
new Thread(main::get, "t2").start();
TimeUnit.SECONDS.sleep(1);
System.out.println();
System.out.println();
System.out.println();
new Thread(main::_get,"t3").start();
new Thread(main::_get,"t4").start();
}
}
输出结果
t1 invoke get() method
t1 invoke set() method
t2 invoke get() method
t2 invoke set() method
t3 invoke _get() method
t3 invoke _set() method
t4 invoke _get() method
t4 invoke _set() method
自旋锁
自旋锁(spinlock):当一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环。
优点:
自旋锁不会使线程状态发生切换,一直处于用户态,即线程一直都是active的;不会使线程进入阻塞状态,减少了不必要的上下文切换,执行速度快
非自旋锁在获取不到锁的时候会进入阻塞状态,从而进入内核态,当获取到锁的时候需要从内核态恢复,需要线程上下文切换。 (线程被阻塞后便进入内核(Linux)调度状态,这个会导致系统在用户态与内核态之间来回切换,严重影响锁的性能)
缺点
若锁被其他线程长时间占用,由于一直死循环,会带来许多性能上的开销。
java实现自旋锁
package demo;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
public class SpinLock {
AtomicReference<Thread> reference = new AtomicReference<>();
public void lock() {
Thread thread = Thread.currentThread();
while (!reference.compareAndSet(null, thread)) {
}
}
public void unlock() {
Thread thread = Thread.currentThread();
reference.compareAndSet(thread, null);
}
public static void main(String[] args) throws InterruptedException {
SpinLock spinLock = new SpinLock();
new Thread(() -> {
spinLock.lock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLock.unlock();
}, "t2").start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> {
spinLock.lock();
spinLock.unlock();
}, "t2").start();
}
}
实现可重入自选锁
思路为维持一个状态变量,记录当前lock的次数。
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public class SpinLock {
AtomicReference<Thread> reference = new AtomicReference<>();
private AtomicInteger num = new AtomicInteger(0);
public void lock() {
Thread thread = Thread.currentThread();
if (reference.get() == thread) {
num.incrementAndGet();
return;//当前锁已经获取了,直接return
}
while (!reference.compareAndSet(null, thread)) {
}
}
public void unlock() {
Thread thread = Thread.currentThread();
if (reference.get() != thread) return;
if (num.get() > 0) {//多次lock
num.decrementAndGet();
} else {
reference.compareAndSet(thread, null);
}
}
public static void main(String[] args) throws InterruptedException {
SpinLock spinLock = new SpinLock();
new Thread(() -> {
spinLock.lock();
System.out.printf("%s\tlock%n", Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLock.unlock();
System.out.printf("%s\tunlock%n", Thread.currentThread().getName());
}, "t1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> {
spinLock.lock();
System.out.printf("%s\tlock%n", Thread.currentThread().getName());
spinLock.unlock();
System.out.printf("%s\tunlock%n", Thread.currentThread().getName());
}, "t2").start();
}
}
## 读写锁
在java中,ReentrantLock和synchronized都是独占锁,也就是当一个线程获取到锁后,其他线程会阻塞。
使用ReentrantLock和synchronized可以保证线程获取和写入资源的安全,但是在读多写少的场景下,如果每次对读操作都加上独占锁,那么会降低读的性能。
在此基础上,有了读写锁的应用场景,一般的缓存操作(读缓存和写缓存),更适合用读写锁。
### 测试代码
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.stream.IntStream;
class Cache {
private volatile Map<Integer, Object> map = new HashMap<>();//对于线程共同操作的资源,需要加上volatile
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();//读写锁
public void put(Integer num, Object o) {
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t正在写入," + num + ":" + o);
map.put(num, o);
System.out.println(Thread.currentThread().getName() + "\t写入完成");
} finally {
lock.writeLock().unlock();
}
}
public void get(Integer num) {
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t正在读取," + num);
Object o = map.get(num);
System.out.println(Thread.currentThread().getName() + "\t读取完成," + num + ":" + o);
} finally {
lock.readLock().unlock();
}
}
}
public class Main {
public static void main(String[] args) {
Cache cache = new Cache();
IntStream.range(0, 10).forEach(i -> {
new Thread(() -> cache.put(i, i), String.valueOf(i)).start();
});
IntStream.range(0, 10).forEach(i -> {
new Thread(() -> cache.get(i), String.valueOf(i)).start();
});
}
}
输出
0 正在写入,0:0
0 写入完成
5 正在写入,5:5
5 写入完成
1 正在写入,1:1
1 写入完成
7 正在写入,7:7
7 写入完成
2 正在写入,2:2
2 写入完成
3 正在写入,3:3
3 写入完成
4 正在写入,4:4
4 写入完成
6 正在写入,6:6
6 写入完成
8 正在写入,8:8
8 写入完成
9 正在写入,9:9
9 写入完成
0 正在读取,0
0 读取完成,0:0
1 正在读取,1
2 正在读取,2
2 读取完成,2:2
1 读取完成,1:1
4 正在读取,4
4 读取完成,4:4
3 正在读取,3
6 正在读取,6
7 正在读取,7
7 读取完成,7:7
5 正在读取,5
8 正在读取,8
6 读取完成,6:6
3 读取完成,3:3
8 读取完成,8:8
9 正在读取,9
5 读取完成,5:5
9 读取完成,9:9
由结果可见,在线程进行写操作时,其操作是没有被阻塞的。
在线程进行读操作时,可以由多个线程来同时读取。
ReentrantReadWriteLock的特性
①具有与ReentrantLock类似的公平锁和非公平锁的实现:默认的支持非公平锁,对于二者而言,非公平锁的吞吐量由于公平锁;
②支持重入:读线程获取读锁之后能够再次获取读锁,写线程获取写锁之后能再次获取写锁,也可以获取读锁。
③锁能降级:遵循获取写锁、获取读锁在释放写锁的顺序,即写锁能够降级为读锁
https://www.cnblogs.com/fsmly/p/10721433.html
最新文章
- slf4i + logback 配置
- [iOS]关于状态栏(UIStatusBar)的若干问题
- sudo: unable to resolve host ubuntu提示的解决
- Sunglasses
- (组合数学3.1.2.1)POJ 2249 Binomial Showdown(排列组合公式的实现)
- cocos2d-iphone加入芒果广告
- 编写一个单独的Web Service for Delphi7(步骤)
- EcStore操作笔记
- web.xml中contextConfigLocation的作用(转)
- 文件的上传(表单上传和ajax文件异步上传)
- 3360: [Usaco2004 Jan]算二十四
- java前后端分离是否会成为趋势
- python-复杂生成式
- iOS 在object-c 中调用c文件 方法
- 安卓开发 UI入门
- 框架-spring源码分析(一)
- 简述this,call,apply,bind之间的关系
- 20-list简单使用:
- 1122 Hamiltonian Cycle
- pyc是个什么鬼?
热门文章
- 阿里Canal中间件的初步搭建和使用
- 暑期java(面向对象设计)学习第一阶段总结
- Python中匿名函数与内置高阶函数详解
- git使用-远程仓库(github为例)
- [转]解决The requested resource is not available的方法
- Visual Studio 2017版本15.9现在可用
- C#LeetCode刷题之#720-词典中最长的单词(Longest Word in Dictionary)
- JavaScript Object的defineProperty / getOwnPropertyDescriptor
- Dubbo系列之 (二)Registry注册中心-注册(2)
- noip复习——逆元