当前位置: 首页> 娱乐> 明星 > 美国免费虚拟主机_北京商场购物中心排名_中国关键词官网_百度搜索推广是什么

美国免费虚拟主机_北京商场购物中心排名_中国关键词官网_百度搜索推广是什么

时间:2025/7/9 8:06:50来源:https://blog.csdn.net/yj20040627/article/details/142692263 浏览次数:0次
美国免费虚拟主机_北京商场购物中心排名_中国关键词官网_百度搜索推广是什么

目录

  • 一、synchronized详解
    • 1.1 互斥
    • 1.2 可重入
  • 二、死锁
    • 2.1 死锁成因
    • 2.2 避免死锁

一、synchronized详解

1.1 互斥

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

语法:

synchronized(变量){
//修改操作
}

()括号内的变量不重要,作用是区分加锁对象是否一样,如果对同一个对象加锁,那么两个操作就会产生“blocked”锁竞争阻塞问题,后一个线程就会等到前一个线程解锁再执行。
进入左大括号 ‘{’ 就是加锁,出了右大括号 ‘}’ 就是解锁。

写一个例子,就会出现预期结果10000:

public class Demo7 {private static int ret;public static void main(String[] args) throws InterruptedException {Object block = new Object();Thread thread1 = new Thread(() -> {for (int i = 0; i < 5000; i++) {                synchronized (block){ret++;}}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 5000; i++) {synchronized (block){ret++;}}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println(ret);;}
}

synchronized还可以修饰方法(静态方法也行)。

  • synchronized修饰实例方法:
class Counter{public int ret;public void increase1() {synchronized (this) {ret++;}}//简化版本synchronized public void increase2() {ret++;}
}
  • synchronized修饰静态方法:相当于修饰这个类
class Counter{private static int ret2;public static void increase3() {synchronized (Counter.class) {ret2++;}}//简化版本synchronized public static void increase4() {ret2++;}
}

1.2 可重入

可重入就是指一个线程连续针对一个对象加多次锁,不会出现“死锁”现象称为可重入。

死锁:自己把自己锁死。
举个例子,假如synchronized不是可重入锁:

synchronized (block) {synchronized(block) {//代码} //右大括号}2
}  //右大括号}1

在进入第一个synchronized的时候,加上一把锁,此时已经是“锁定状态”,
当我们进入到第二个synchronized的时候要加锁,就发生“阻塞等待”,就要等到第一个锁走到右大括号}1解完锁才能加,
然而第一个锁走到右大括号}1解锁,又需要第二把锁创建走完到右大括号}2。
这是线程就卡死了,这就是死锁。

synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题;

  • 可重入机制会在第一次加锁的时候记录是那个线程加的锁,然后下一次加锁如果是这个被记录线程,就直接加锁成功。这就是可重入锁的 "线程持有者"信息。
  • 可重入锁还会有一个“计数器”信息,加一把锁就加一,解一把锁就减一,当计数器递减为 0 的时候, 才真正释放锁。

二、死锁

  • 前面所说,一个线程两把锁,如果不是可重入锁就死锁了;
  • 还有两个线程两把锁,是不是可重入锁都要死锁。两个线程T1、T2,两把锁A、B;T1获取锁A,T2获取锁B,T2尝试获取锁B,T2尝试获取锁A。就如“车钥匙锁房间里了,房间钥匙锁车里了”。
public class Demo9 {public static void main(String[] args) {Object block1 = new Object();Object block2 = new Object();Thread thread1 = new Thread(()->{synchronized (block1) {System.out.println("thread1加block1");synchronized (block2) {System.out.println("thread1加block2");}}});Thread thread2 = new Thread(()->{synchronized (block2) {System.out.println("thread2加block2");synchronized (block1) {System.out.println("thread2加block1");}}});thread1.start();thread2.start();}
}
  • N个线程,M把锁(相当于两个线程两把锁的进阶版本):经典模型哲学家就餐问题

5个哲学家,5只筷子,哲学家坐在圆桌边,桌上放有面条,每只筷子放在每个哲学家的中间。

  1. 每个哲学家,会做两件事:
    1.1.思考人生.放下筷子,啥都不干
    1.2 吃面条.拿起左右两侧的两根筷子,开始吃面条,
  2. 哲学家啥时候吃面条,啥时候思考人生,是随机的
  3. 哲学家吃面条啥时候吃完,也是随机的,
  4. 哲学家正在吃面条的过程中,会持有左右两侧的筷子。此时相邻的哲学家如果也想吃面条,就需要阻塞等待,

当出现极端情况,每个哲学家都想吃面条,都拿起自己左手边的筷子,并且不会在没吃到面条情况下放下筷子,这时就是死锁了。

2.1 死锁成因

四个必要条件:

  1. 互斥使用(锁的基本特性):当一个线程拿到一把锁后,另一个线程要拿到这把锁就要阻塞等待;
  2. 不可抢占(锁的基本特性):当一把锁被线程拿到后,其他线程不能抢占,只能等线程自己释放锁;
  3. 请求保持(代码结构):当一个线程拿到一把锁后,再去拿其它锁的时候,已经被拿到的锁不会被释放;
  4. 循环/环路 等待(代码结构):阻塞等待的依赖关系形成环了。

2.2 避免死锁

只要上诉四个条件不成立一个就可以。
条件1,2是锁自带的特性,不能改变。

  • 对于条件3,改变代码结构,避免锁嵌套逻辑;
  • 对于条件4,可以约定加锁顺序,便面等待依赖关系成环。
    如上面的哲学家就餐问题,给每个筷子从1-5顺序编号,规定每次拿筷子只能先拿小号筷子。
  • 银行家算法,但是这种算法过于麻烦一般不用。
关键字:美国免费虚拟主机_北京商场购物中心排名_中国关键词官网_百度搜索推广是什么

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: