javaEE初阶————多线程初阶(3)

news/2025/2/8 21:58:00 标签: java, 开发语言

大家新年快乐呀，今天是第三期啦，大家前几期的内容掌握的怎么样啦？

1，线程死锁 

1.1 构成死锁的场景

a）一个线程一把锁

这个在java中是不会发生的，因为我们之前讲的可重入机制，在其他语言中可能会发生的；

java">public static void main(String[] args) throws InterruptedException {

        Object locker = new Object();

        Thread t1 = new Thread(()->{
            synchronized (locker){
                synchronized (locker){
                    System.out.println(1111);
                }
            }
        });

        t1.start();
        t1.join();
        System.out.println("main");
    }

按理来说，t1线程刚进synchronized就获取到了锁对象，就要保持，进入第二个synchronized就要请求第一个锁对象，第一个要保持不给你锁对象，它让第二个先给他，第二个synchronized说你先给我我才有锁对象给你呀，它俩就这么一直僵持着，但是java有可重入机制不会发生这样的死锁的； 

b）两个线程两把锁

我们来模拟一个吃饺子的过程，小明小亮吃饺子，有酱油和醋对应两把锁，他们喜欢这两个东西一起加（我不喜欢），

java">public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋

        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("获取到了酱油");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                synchronized (locker2){
                    System.out.println("酱油和醋都是" + Thread.currentThread().getName() + "的啦");
                }
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker2){
                System.out.println("获取到了醋");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                synchronized (locker1){
                    System.out.println("酱油和醋都是" + Thread.currentThread().getName() + "的啦");
                }
            }
        },"小亮");

        t1.start();
        t2.start();
    }
}

我们来看运行结果

没有人获得酱油和醋，并且程序也没有正常停止，

 

这俩线程都因为锁竞争阻塞了，这就构成了死锁，我们加那个sleep是为了保证小亮拿醋，小明拿酱油之后再竞争互相的，不然可能就小明太快了直接全拿走了，或者小亮全拿走了； 

c）n个线程m把锁

一个很经典的模型，哲学家就餐问题：

1，哲学家可以放下筷子思考

2，哲学家拿筷子可以吃面条（没有洁癖）两根才能吃

但是哲学家都很固执，拿到了筷子是不会放手的，那么如果在当前这个图上每个人都想吃面条，每个人都到拿到了面前的筷子，要吃面条还需要一个筷子，他们就会想要别人的筷子，然而每个人都不会放开自己的筷子，你等我，我等你，最后大家都饿死，这就构成了死锁；但是按理来说这个模型出现这样的情况非常非常低那么中国10几亿人，这个概率就会无限放大，线程安全要做到完全没有危险的概率；

1.2 死锁的四个必要条件

a）互斥（基本特性）

一个线程获取到锁，其他线程再想获得这个锁就要阻塞等待；

b）不可剥夺（基本特性）

也可以叫不可抢占，如果线程1获取到了锁，线程2再想获取锁是不可以抢夺的，必须阻塞等待；

c）请求和保持

一个线程获取了锁1之后再不放弃锁1的前提下获取锁2；

d）循环等待

a等待b，b等待c，c等待d，d等待a；构成死锁循环；

1.3 如何避免死锁

我们刚才说的构成死锁的四种情况中，互斥和不可剥夺是锁的基本特性，我们是改变不了的，我们只能去改变（请求保持和循环等待）；

a）打破请求和保持

请求和保持大概率是发生在嵌套中的，我们可以用并列来代替嵌套，但是通用性较低；

我们就拿刚才的吃饺子来举例子把；

java">public class Demo1 {
    public static void main(String[] args) {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小明拿到酱油");
            }

            try {
                Thread.sleep(1111);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (locker2){
                System.out.println("小明拿到醋");
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小亮拿到酱油");
            }

            try {
                Thread.sleep(1111);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (locker2){
                System.out.println("小亮拿到醋");
            }
        },"小亮");

        t1.start();
        t2.start();

    }
}

并列锁，虽然没有构成死锁，但是违背了我们的想法就是让小明和小亮获得两个锁，刚才说的通用性不强也是在这里； 

b）打破循环等待

第二个方法，改变加锁的顺序，我们还有吃饺子的例子，但是这次要拿到两个锁：

java">public class Demo2 {
    public static void main(String[] args) {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小明拿到酱油啦");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (locker2){
                    System.out.println("小明拿到醋和酱油啦");
                }
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小亮拿到酱油啦");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (locker2){
                    System.out.println("小亮拿到醋和酱油啦");
                }
            }
        },"小亮");

        t1.start();
        t2.start();
        
    }
}

我们改变了加锁的顺序，

 

也是能避免死锁问题的；

———————————————————————————————————————————

2，内存可见性

这也是导致线程安全的问题之一

我们来写一个例子嗷：
 

java">import java.util.Scanner;

public class Demo3 {
    static int i = 0;
    public static void main(String[] args) {
        Object obj = new Object();


        Thread t1 = new Thread(()->{
            while(i==0){

            }
            System.out.println("结束");
        });

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            Scanner scanner = new Scanner(System.in);
            synchronized (obj){
                i = scanner.nextInt();
            }
        });
        t1.start();
        t2.start();
    }
}

我们来看这个代码，t1线程根据i的数值一直循环直到i的值被t2线程修改才停止，事实是这样的吗。我们来试试，

无法暂停，这是为啥：

这就是因为内存可见性问题，程序员的水平参差不齐，java大佬为了照顾我们这样的小卡拉米，就弄了个编译器优化，所以我们写的代码并不会直接执行，我们刚才写的while(i==0)这段代码，我们要等待t2线程来修改i，可能我们就用了几秒的时间但对于t1线程，这这边是沧海桑田，万物轮回，谁还记得什么t1呀它等于0就得了，再底层一点解释呢，就是有“工作内存” 和 “主内存”我们应该是从主内存中拿到数据，放到工作内存中，再从工作内存放回主内存，但是这么一直一直重复，去主内存的时间开销是工作内存的几千倍，编译器就不去主内存了直接去工作内存中拿数据，但是后期修改了主内存，然而此处代码已经完全忽略主内存了，就无法修改了；这就是内存可见性问题那么怎么避免呢？

———————————————————————————————————————————

3，volatile 关键字

我们可以使用volatile关键字避免内存可见性问题；

3.1 volatile 能保证内存可见性

java">import java.util.Scanner;

public class Demo3 {
    volatile static int i = 0;
    public static void main(String[] args) {

        Object obj = new Object();


        Thread t1 = new Thread(()->{
            while(i==0){

            }
            System.out.println("结束");
        });

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            Scanner scanner = new Scanner(System.in);
            synchronized (obj){
                i = scanner.nextInt();
            }
        });
        t1.start();
        t2.start();
    }
}

看，解决了吧，就加了一个volatile；

3.2 volatile 不能保证原子性

还记得原子性吗，就是这个操作在底层是不是原子的，是不是分几步，再多线程中会影响到这个操作，我们拿之前那个两个线程修改一个整形：

java">public class Demo4 {
    volatile static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for(int i=0;i<100000;i++){
                count++;
            }
        });
        Thread t2 = new Thread(()->{
            for(int i=0;i<100000;i++){
                count++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + count);
    }
}

所有我们只有使用锁才行；

———————————————————————————————————————————

4，wait 和 notify

这是个什么玩意，线程不是随机调度，抢占式执行的吗，我们可以用这个玩意稍加限制，协调线程之间的逻辑顺序；

4.1 wait() 方法

这个东西跟锁和sleep不一样，都是等待，但是是有区别的，wait(）是等的时候会释放锁，被唤醒再拿到锁而sleep这个byd它抱着锁睡，............锁的话就是阻塞等待嘛，

我们来试试wait（）方法是搭配锁来使用的，最好还要加while循环

java">public class Demo5 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println(1000);
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(2000);
            }
        });

        t1.start();
    }
}

 我们来看看运行结果

死等，因为没有东西能够唤醒wait（）；

我们可以设置超时时间，也可以使用notify方法；

java">public class Demo5 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println(1000);
                try {
                    locker.wait(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(3000);
            }
        });

        t1.start();
    }
}

这样代码会在2秒后打印3000；

4.2 notify() 方法

用来唤醒wait（）注意这些都是搭配锁对象来用的；

对于notify，如果存在多个使用同一个锁对象的wait，它没有规律，会随机唤醒一个wait

java">public class Demo6 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println("线程1获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1释放锁");
            }
        });
        Thread t2 = new Thread(()->{
            System.out.println("Thread 2");
            synchronized (locker){
                System.out.println("线程2获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2释放锁");
            }
        });

        t1.start();
        t2.start();
        Thread.sleep(1000);
        synchronized (locker){
            locker.notify();
        }

    }
}

 线程1成功释放了锁，说明notify唤醒了线程1的waite

我们再试试

4.3 notifyAll() 方法

这个就是全部释放

java">public class Demo7 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println("线程1获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1释放锁");
            }
        });
        Thread t2 = new Thread(()->{
            System.out.println("Thread 2");
            synchronized (locker){
                System.out.println("线程2获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2释放锁");
            }
        });

        t1.start();
        t2.start();
        Thread.sleep(1000);
        synchronized (locker){
            locker.notifyAll();
        }

    }
}

完美

4.4 wait 和 sleep的对比

这个没啥好说的了，wait先加锁，到。wait（）操作的时候释放锁，唤醒的时候再拿着锁，而sleep纯抱着锁睡，还会被interrupt唤醒，说实话抱着锁睡听不好的，可能会有很多线程都等着它很浪费时间的，sleep会释放Cpu的资源，不再占用了；就这样吧，大家加油，等我更新下一期；


http://www.niftyadmin.cn/n/5845322.html

相关文章

wxWidgets生成HTML文件，带图片转base64数据

wxWidgets生成HTML文件，带图片转base64数据

编译环境大家可以看我之前的文章，CodeBlocks + msys2 + wx3.2，win10 这里功能就是生成HTML文件，没用HTML库，因为是自己固定的格式，图片是一个vector，可以动态改变数量的。 效果如下： #include <wx/string.h> #include <wx/file.h> #include <wx/ima…
阅读更多...
Go 语言 | 入门 | 快速入门

Go 语言 | 入门 | 快速入门

快速入门 1.第一份代码 先检查自己是否有正确下载 Go&#xff0c;如果没有直接去 Go 安装 进行安装。 # 检查是否有 Go $ go version go version go1.23.4 linux/amd64然后根据 Go 的入门教程 开始进行学习。 # 初始化 Go 项目 $ mkdir example && cd example # Go…
阅读更多...
【MySQL】向后兼容设计规范（无回滚场景）

【MySQL】向后兼容设计规范（无回滚场景）

MySQL 向后兼容设计规范&#xff08;无回滚场景&#xff09; 在 不支持数据库回滚 且需保证 长期向后兼容性 的系统中&#xff0c;需通过 架构设计 和 流程管控 规避风险。以下是关键设计规范&#xff1a; 一、变更流程规范 变更分类分级 变更类型风险评估等级审批流程测试要求…
阅读更多...
TCN时间卷积神经网络多变量多步光伏功率预测（Matlab）

TCN时间卷积神经网络多变量多步光伏功率预测（Matlab）

代码下载&#xff1a;TCN时间卷积神经网络多变量多步光伏功率预测&#xff08;Matlab&#xff09; TCN时间卷积神经网络多变量多步光伏功率预测 一、引言 1.1、研究背景和意义 随着全球能源危机的加剧和环保意识的提升&#xff0c;可再生能源&#xff0c;尤其是太阳能&…
阅读更多...
JS实现一个通用的循环填充数组的方法

JS实现一个通用的循环填充数组的方法

function createFilledArray(length, pattern) {return Array.from({ length }, (_, i) > pattern[i % pattern.length]); }// 示例 const result createFilledArray(8, [1, 2, 3]);console.log(result); // [1, 2, 3, 1, 2, 3, 1, 2]解析&#xff1a; createFilledArray(…
阅读更多...
Linux运维——文件内容查看编辑

Linux运维——文件内容查看编辑

文件内容查看编辑 一、Linux 文件内容查看编辑要点二、命令常见用法2.1、cat2.2、head2.3、tail2.4、more2.5、less2.6、sed2.7、vi2.8、grep 一、Linux 文件内容查看编辑要点 连接文件并打印到标准输出设备 - 使用 cat显示指定文件的开头若干行 - 使用 head显示指定文件的末尾…
阅读更多...
先进制造aps专题二十八 生产排程仿真引擎和工厂生产仿真引擎的设计

先进制造aps专题二十八 生产排程仿真引擎和工厂生产仿真引擎的设计

一 排产仿真引擎的设计 主要分为仿真模型&#xff0c;仿真模型逻辑和仿真框架这三个部分 1 仿真模型 和算法排产不一样&#xff0c;在算法排产里&#xff0c;机器对应的是数据库记录&#xff0c;排产逻辑是写在整体的算法里的&#xff0c;而仿真排产&#xff0c;机器对应的是…
阅读更多...
Spring JDBC模块解析 -深入SqlParameterSource

Spring JDBC模块解析 -深入SqlParameterSource

在前面的博客中&#xff0c;我们探讨了Spring Data Access Module中的主要组件&#xff1a; JdbcTemplate和SimpleJdbcInsert。在这两部分的基础上&#xff0c;我们将继续探讨更详细 的用法&#xff0c;包括如何使用RowMapper和SqlParameterSource等高级主题。 JdbcTemplate …
阅读更多...
最新文章

Copyright @ 2022~2023