大家好,我是
方圆
查漏补缺了一下锁的知识点儿
目录
1. synchronized
它会在发生异常时自动释放锁
2. 你知道Git是乐观锁吗?
当我们在向远程仓库push的时候,git会检查远端仓库的版本是不是要比我们现在的版本
要高,如果是的话,就表示有人修改了远端代码,我们不能进行提交,需要先进行同步;如果版本
一致的话,则能够提交成功
2.1 在MySQL中实现乐观锁
我们需要创建出一个单独的version
列,用来标记版本号,这样每次我们对数据进行修改的时候,则会对版本号进行验证
SQL语句如下
UPDATE active SET num = 3 ,`version` = `version` + 1 WHERE id = 1 AND `version` = 1
2.2 乐观锁的适用场景
乐观锁:适用于读多 写少
的场景,这样不加锁能大幅的提高效率
悲观锁:适合大并发
,代码复杂
或者循环量大
3. 公平锁和非公平锁
- 公平锁:
不允许插队
的哟,谁先来谁就会先获取到锁 - 非公平锁:
允许插队
的哟,这样能提高效率
,避免了唤醒带来的空档期
,也是ReentrantLock的默认策略
3.1 来,看看这个特例
- ReentrantLock中有一个
tryLock方法
,它实在是很厉害,它并不遵守我们既定的公平策略
,怎么说呢,就是一旦有线程将锁的资源释放了出来,那么这个执行了tryLock方法的线程就能获取到锁
,即便已经有线程在前面进行排队了,它就像VIP一样
4. 读写锁的插队策略
- 公平锁:不允许插队
- 非公平锁:
写锁
可以随时插队;读锁
仅在阻塞队列的头节点是想要获取读锁
的线程的时候,可以插队;当阻塞队列的节点是想要获取写锁
的线程时,那么不能进行插队
,这样能够避免发生饥饿
现象(饥饿就是获取写锁被一直插队,一直也获取不到锁)
4.1 代码测试
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadAndWriteDemo2 {
private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
private static ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
private static ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
public static void read() {
System.out.println(Thread.currentThread().getName() + "尝试获取读锁");
readLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了读锁");
TimeUnit.MILLISECONDS.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
readLock.unlock();
}
}
public static void write() {
System.out.println(Thread.currentThread().getName() + "尝试获取写锁");
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了写锁");
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
writeLock.unlock();
System.out.println(Thread.currentThread().getName() + "释放了写锁");
}
}
public static void main(String[] args) {
new Thread(() -> write(),"A").start();
new Thread(() -> read(),"B").start();
new Thread(() -> read(),"C").start();
new Thread(() -> {
for (int i = 0; i < 1500; i++) {
new Thread(() -> read(),String.valueOf(i)).start();
}
}).start();
}
}
- 在
非公平
的情况下 ↓
- 在
公平
的情况下↓
5. 写一个死锁
5.1 代码
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class DeadLockDemo2 {
public static void main(String[] args) throws InterruptedException {
DeadLock deadLock = new DeadLock(1);
new Thread(deadLock,"1").start();
TimeUnit.MILLISECONDS.sleep(1);
deadLock.setFlag(2);
new Thread(deadLock,"2").start();
}
}
class DeadLock implements Runnable{
private ReentrantLock lock1 = new ReentrantLock();
private ReentrantLock lock2 = new ReentrantLock();
private int flag;
public DeadLock(int flag) {
this.flag = flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
//TODO tryLock避免死锁式,注意tryLock方法的使用位置,是在if条件中
@Override
public void run() {
if(flag == 1) {
if(lock1.tryLock()) {
try {
System.out.println(Thread.currentThread().getName() + "成功获取到了锁1");
TimeUnit.SECONDS.sleep(1);
if(lock2.tryLock()) {
try {
System.out.println(Thread.currentThread().getName() + "成功获取到了锁2");
}finally {
lock2.unlock();
}
}else {
System.out.println(Thread.currentThread().getName() + "获取锁2失败");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock1.unlock();
}
}else {
System.out.println(Thread.currentThread().getName() + "获取锁1失败");
}
}else {
if(lock2.tryLock()) {
try {
System.out.println(Thread.currentThread().getName() + "成功获取到了锁2");
TimeUnit.SECONDS.sleep(1);
if(lock1.tryLock()) {
try {
System.out.println(Thread.currentThread().getName() + "成功获取到了锁1");
}finally {
lock1.unlock();
}
}else {
System.out.println(Thread.currentThread().getName() + "获取锁1失败");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock2.unlock();
}
}else {
System.out.println(Thread.currentThread().getName() + "获取锁2失败");
}
}
}
//TODO 死锁式
/*@Override
public void run() {
if(flag == 1) {
lock1.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了锁1");
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "尝试获取锁2");
lock2.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了锁2");
}finally {
lock2.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock1.unlock();
}
}else {
lock2.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了锁2");
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "尝试获取锁1");
lock1.lock();
try {
System.out.println(Thread.currentThread().getName() + "获取到了锁1");
}finally {
lock1.unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock2.unlock();
}
}
}*/
}
5.2 总结
以上代码中,提供了两种方法,一个是会出现死锁
的情况,调用的是lock方法
;另一个是不会发生死锁
的情况,也就是使用了tryLock方法
,这个方法可以尝试获取锁,获取不到锁就会自动放弃,当然我们自己也能指定等待时间,同时我们也要注意tryLock的使用位置,它是在if条件语句
中的,与lock方法有些区别
若发生死锁现象,我们有一种解决方案,
使用jps -l 命令显示出进程的信息,我们想要的就是进程号
之后根据进程号我们使用 jstack 进程号 我们就能查看堆栈信息了
6. 自旋锁
自旋锁:阻塞或唤醒一个Java线程需要CPU切换状态来完成,需要耗费时间,如果当我们的代码过于简单的时候,切换状态消耗的时间可能会比用户代码执行的时间还要长
,为了避免这种情况,自旋锁应需而生,它会让线程进行不断的自旋,直到获取到锁,避免了先换线程的开销(不过JVM中会对自旋锁进行优化,有一个自旋次数的阈值,超过之后就会停止自旋)
atomic包
下的类基本上都是自旋锁的实现,例如AtomicInteger,它的原理是CAS,它的getAndIncrement方法
(自增)就是利用的自旋锁,调用Unsafe的getAndAddInt方法
,如下,直至修改成功才停止
-
局限:
如果自旋锁被占用的时间太长,那么自旋的线程只会白白浪费处理器资源 -
适用场景
在并发度不是特别高的情况下,而且代码块比较简单的时候
6.1 手写一个简单的自旋锁
public class SpinLockDemo {
private AtomicReference<Thread> spinLock = new AtomicReference<>();
public void lock() {
Thread cur = Thread.currentThread();
while(spinLock.compareAndSet(null,cur)) {
}
}
public void unLock() {
Thread cur = Thread.currentThread();
spinLock.compareAndSet(cur,null);
}
}
加油儿!