Java【多线程】synchronized关键字

原创已于 2024-10-17 00:41:02 修改 · 959 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2024-10-16 20:40:12 首次发布

synchronized关键字-监视器锁monitor locker

synchronized的特性

1.互斥

synchronized 会起到互斥效果, 某个线程执⾏到某个对象的 synchronized 中时, 其他线程如果也执⾏到同⼀个对象 synchronized 就会阻塞等待

进⼊ synchronized 修饰的代码块, 相当于加锁

退出 synchronized 修饰的代码块, 相当于解锁

多个线程针对同一个锁对象加锁才会产生互斥（锁冲突/锁竞争）

synchronized(锁对象）{//加锁

一些要保证安全的代码

}//解锁

synchronized修饰普通方法，相当于个给this加锁

synchronized修饰静态方法，相当于给类对象加锁

2.可重入

synchronized 同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题

如何理解把自己锁死

public void add(){
  synchronized(this){
      count++;
  }
}

synchronized(counter){
  counter.add();
}

一旦调用的层次较深就容易出现这样的情况

要想解除阻塞需要往下执行才可以

要往下执行就要等到第一次的锁被释放

这样的问题就称为“死锁”dead lock

1.第一次加锁能成功（锁没有人使用）

2.第二次进行加锁，此时意味着锁对象已经被占用的状态，第二次加锁就会触发阻塞等待

死锁是一个非常严重的bug使代码执行到这一块之后就卡住

为了解决上述的问题，java的synchronized就引入了可重入的概念

当某个线程针对一个锁加锁成功之后

后续该线程再次针对这个锁进行加锁

不会触发阻塞而是直接往下走

因为当前这把锁就是被这个线程持有

但是，如果是其他线程尝试加锁就会正常阻塞

可重入锁的实现原理，关键在于让锁对象内部保存，当前是哪个线程持有的这把锁

后续有线程针对这个锁加锁的时候，对比一下，锁的持有者的线程是否和当前加锁的线程是同一个

synchronized(counter){//真正加锁 1
  synchronized(counter){//放行 2
    synchronized(counter){//放行 3
      counter.add();
    }//3->2
  }//2->1
}//1->0

最外层，真正加锁

最外层，真正解锁

站在jvm的视角，看到多个}需要执行

jvm如何知道哪个}是真正解锁的那个

先引入一个变量，计数器（0）

每次触发{的时候，count++；

每次触发}的时候，count--；

当count--为0的时候就是真正需要解锁的时候

如何自己实现一个可重入锁？

1.在锁内部记录当前是哪个线程持有的锁，后续每次加锁，都进行判定

2.通过计数器，记录当前加锁的次数，从而确定何时真正进行解锁

关于死锁

一个线程，一把锁，连续加锁两次

两个线程，两把锁，每个线程获取到一把锁之后，尝试获取对方的锁

           synchronized (locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){
                    System.out.println("t1线程两个锁都获取到");
                }
            }

必须是，拿到第一把锁，再拿第二把锁（不能释放第一把锁）

Thread-0因为竞争锁的缘故而阻塞了

如果不加sleep是否还会出现一样的现象

不一定

这就看具体的顺序

加上sleep为了确保

t1拿到locker1

t2拿到locker2

等待1s

t1拿到locker2

t2拿到locker1

如果不加sleep，很可能t1一口气就把locker1和locker2都拿到了，这个时候t2还没开动