Java多线程（02）

news2024/10/6 8:24:06

一、如何终止线程

终止线程就是要让 run 方法尽快执行结束

1. 手动创建标志位

可以通过在代码中手动创建标志位的方式，来作为 run 方法的执行结束条件；

    public static void main(String[] args) throws InterruptedException {
        boolean flag = true;
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag){
                    System.out.println("线程执行中 ");
                }
            }
        });
        t.start();
        Thread.sleep(100);
        flag = false;
    }

如果将标志位定义在方法内部，这样编译器会报错，原因涉及到一个语法规则：匿名内部类的变量捕获， 匿名内部类可以使用方法中定义的变量，但这个变量必须是 final 的或者是 "事实" final 的；

所以要将标志位定义在类中，即属性，那这样又为什么不报错了呢？这又涉及到内部类 访问外部类的成员问题，内部类可以直接访问外部类的成员，不会受到变量捕获的影响；

public class Demo3 {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("线程执行中 ");
                }
            }
        });
        t.start();
        Thread.sleep(10);
        flag = false;
    }
}

可以看出上述方法确实终止了线程 t，但是如果，但如果线程 t 在 sleep 时，主线程再修改变量，那么 线程 t 就不能及时响应了；例如如下代码：

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    System.out.println("t线程执行中 " + System.currentTimeMillis());
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("t线程执行结束 " + System.currentTimeMillis());
                }
            }
        });
        t.start();
        Thread.sleep(100);
        flag = false;
        System.out.println("主线程通知 t线程 执行结束" + System.currentTimeMillis());
    }

可以看出主线程修改了标志位之后，在休眠状态下的 t 线程没有立即结束； 

2. 使用 Thread 类提供的方法

使用 Thread.currentThread().isInterrupted() 方法作为内部标志位，使用 t.interrupt() 方法终止线程；

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("t线程正在执行 ");
                }
            }
        });
        t.start();
        Thread.sleep(1);
        t.interrupt();
    }

 上述代码中，t 线程执行了 1 ms之后自动结束了；

那如果主线程调用 t.interrupt() 方法的时候 t 线程正在 sleep 呢？看看下面这个例子：

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("t线程正在执行 ");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        Thread.sleep(100);
        t.interrupt();
    }

 可以看到，t 线程直接抛出了一个 InterruptedException，同时对应到 使用 sleep 方法必须进行手动的处理异常，防止了在 sleep 的时候，调用 interrupt 方法而没有及时感知；

二、线程等待

线程等待就是让一个线程等待另一个线程执行结束，再继续执行；实现线程等待的方式有 join 和wait，sleep也算一种吧；

1. join

join 在哪个线程内调用，哪个线程就阻塞等待，默认死等待，不释放锁资源，也可以设置一个最长的等待时间；通过影响线程结束的先后顺序实现线程等待，join 是 Thread 类提供的方法，；

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("线程执行中 i = " + i);
                }
            }
        });
        t.start();
        System.out.println("开始等待");
        t.join();
        System.out.println("等待结束");
    }

但如果 t 线程要执行很久，也可以通过设置最长等待时间再继续执行主线程；例如，通过 t.join(1000); 设置最多等待 1 秒，但当这个时间到了，t 线程不一定执行完了，而是主线程该执行了；

2. wait

wait 让指定的线程进入阻塞状态，wait 方法也可以指定超时时间，与 wait 相对应的方法是 notify，notify用来唤醒处在 wait 等待中的线程；wait 与 notify 是 Object 类的方法，在使用时都必须放在 synchronized 块中；wait 方法执行要做的事：1）释放锁资源；2）让线程进入阻塞状态；3）当线程被重新唤醒时，重新获取到锁；

wait 结束等待的条件：1）其他线程调用该锁对象的 notify 方法（前提是，使用 synchronized加上锁）；2）wait 等待时间超时(如果 wait 方法指定了超时时间)；3）其他线程调用该等待线程的 interrupted方法，导致 wait 抛出InterruptedException 异常

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("线程执行中 i = " + i);
                    }
                    object.notify();
                }
            }
        });
        t.start();
        System.out.println("开始等待");
        synchronized (object) {
            object.wait();
        }
        System.out.println("等待结束");
    }

使用 wait / notify 不会出现 "线程饿死" 问题；

线程饿死：一个线程释放锁的时候，又去竞争锁，由于该线程已经在 cpu 上执行，故没有调度的过程，进而更容易拿到锁，反复进行此操作，后续线程就无法拿到锁，就会出现 "线程饿死" 问题；使用 wait 时，该线程会释放锁，并进入阻塞，不会参与后续的锁竞争；

三、线程安全 

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

针对上述代码，执行多次的结果是不一样的，这就是线程安全问题； 

产生线程安全问题的原因：

1. 操作系统中，线程的调度方式是随机的（抢占式执行）；

此种情况是操作系统内核决定的，是无法避免的；

2. 两个或多个线程对同一个变量进行修改，并且修改操作不是原子的；

为了避免线程不安全问题，可以尽量减少多个线程对同一个变量的修改，但是有时候就是需要对同一个变量修改，这时候就需要保证修改操作是原子的，那就要使用到 synchronized 来加锁了；

synchronized 在使用时，要搭配一个代码块和一个对象，进入代码块中就会加锁，出了代码块就会解锁，在已经加锁的状态下，另一个线程尝试对该代码块中同一个对象加锁，就会产生 "锁竞争/ 锁冲突"，后一个线程就会阻塞等待，直到前一个线程释放锁为止；

现使用 synchronized 对上述代码进行修改，由于是 count++ 操作是非原子的，故要对 count++ 操作进行加锁；（也可以使用 Integer 的原子类 AtomicInteger 实现原子操作）

public class Demo4 {
    public static int count = 0;
    public static final Object o = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (o) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (o) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

上述代码中是针对同一个对象 o 进行加锁，若是针对不同的对象加锁，则不会有锁竞争，仍然是并发；

当 synchronized 修饰成员方法时，相当于对 this 对象进行加锁，当 synchronized 修饰类方法时，相当于对 类对象 进行加锁；

可重入锁的概念：指一个线程连续针对一把锁加锁两次不会出现死锁，满足该要求就是可重入锁；

死锁问题：

1）一个线程针对同一把锁，连续加锁两次如果是不可重入锁，就会产生死锁；

第一次加锁会成功，第二次加锁就需要等待第一次加的锁释放，但此时第二次加锁的操作在第一次锁的代码块中，第一次加锁要释放，就又得第二次加锁成功，这样就产生了死锁；但如果能让锁记录是哪个线程对它加的锁，并记录加了几层，这样后续再加锁的时候，判断加锁线程是否为持有锁的线程，如果是，则直接加锁成功，此时就可以避免死锁；

    public static void main(String[] args) {
        synchronized (o1){
            synchronized (o2){
                System.out.println("加锁成功");
            }
        }
    }

 

由于 synchronized 是 可重入锁，故此时不会产生死锁； 

2）两个线程两把锁，例如有 t1，t2 线程，o1，o2 对象，t1 已经对 o1 加锁，t2 已经对 o2 加锁，此时 t1 又尝试对 o2 加锁，t2 尝试对 o1 加锁；（此时一定会产生死锁）；

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (o1){
                System.out.println("t1 对 o1 加锁成功");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (o2){
                    System.out.println("t1 对 o2 加锁成功");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (o2){
                System.out.println("t2 对 o2 加锁成功");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (o1){
                    System.out.println("t2 对 o1 加锁成功");
                }
            }
        });
        t1.start();
        t2.start();
    }

可以看到并没有打印 "t1 对 o2 加锁成功" 和 "t2 对 o1 加锁成功"，此时已经产生死锁了；

3）多个线程，对应多把锁，更容易产生死锁；

3. 内存可见性问题 

public class Demo5 {
    public static int flag = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag == 0){
            }
            System.out.println("t1 线程执行结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("请输入 flag: ");
            Scanner in = new Scanner(System.in);
            flag = in.nextInt();
        });
        t1.start();
        t2.start();
    }
}

可以看到在上述代码中， 当 flag 为 0 时，t1 线程会循环执行；t2 线程可以让用户输入一个数来改变 flag 的值，按理来说用户输入非 0，t1 线程应该会终止循环，并打印 "t1 线程执行结束"，然后 t1 线程结束，但运行结果并非这样，这就是内存可见性引起的问题；

t1 线程判断循环的条件 while(flag == 0) 具体操作为：1）load 读取内存中 flag 的值到 cpu 寄存器中；2）使用寄存器中的值和 0 进行比较；

由于这个循环体内没有任何操作（编译器可以检测到），所以这个循环的执行速度是非常快的，所以 编译器为了提高效率，会将读内存优化为读寄存器：编译器只在第一次循环时，才读了内存，并将读到的结果放入寄存器中，后续会直接从寄存器中取值，这样后续 t2 线程修改了 flag 的值（内存中的值），t1 线程并没有感知到，这时 t1 线程自然就不会退出循环了，因为它还用的是寄存器中的值，这时候就要 使用到 volatile 关键字，告诉编译器不要优化，此时会强制读取内存；

public static volatile int flag = 0;

在 flag 定义时使用 volatile 关键字，再次执行程序：

 注意 volatile 只保证内存可见性，不保证原子性，如果两个线程同时对 同一个带有 volatile 修饰的变量进行修改，此时仍会产生线程安全问题；

4. 指令重排序问题

指令重排序也是编译器优化的一种方式：调整原有代码的执行顺序，保证逻辑不变的前提下，提高程序的效率；点这里查看指令重排序的线程安全问题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1707630.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SERVER-----查询（1）

SERVER-----查询（1）

目录 Scott库下载&#xff1a; 一. 查询 1. 计算列 2. distinct 3. betwee... and... 4. in Scott库下载&#xff1a; 在大家学习数据库后期需要使用Scott库进行辅助学习&#xff0c;下面是我从一个叫做 yuhan_Li的博主那复制过来的&#xff0c;大家尽可能访问原文章吧&am…
阅读更多...
南卡、韶音、Cleer开放式耳机如何选？全面对比测评拒绝智商税！

南卡、韶音、Cleer开放式耳机如何选？全面对比测评拒绝智商税！

随着开放式耳机在生活中日益流行&#xff0c;市场上的多样化选择有时也伴随着质量参差不齐的问题&#xff0c;部分产品因成本控制而牺牲了材质和音质&#xff0c;给消费者在寻找高质量耳机时增添了困扰。 作为一名耳机评测领域的从业者&#xff0c;近期我投入大量精力对多款开…
阅读更多...
基于STM32实现智能饮水机控制系统

基于STM32实现智能饮水机控制系统

目录 引言环境准备智能饮水机控制系统基础代码示例&#xff1a;实现智能饮水机控制系统 温度传感器数据读取水泵和加热器控制水位传感器数据读取用户界面与显示应用场景&#xff1a;家庭和办公室的智能饮水管理问题解决方案与优化收尾与总结 1. 引言 本教程将详细介绍如何在S…
阅读更多...
1---Linux下进程的概念(逻辑推导，全干货无废话)

1---Linux下进程的概念(逻辑推导，全干货无废话)

一、进程和程序&#xff1a; 1.1什么是程序&#xff1f; 程序由代码、数据、逻辑、接口和文档组成的一组按特定顺序执行的计算机指令&#xff0c;用于实现特定功能或解决问题。程序存储在磁盘上。 1.2什么是进程&#xff1f; 进程是一个正在执行的程序实例&#xff0c;包含程…
阅读更多...
数据库查询——kettle开发20

数据库查询——kettle开发20

一、数据库查询 数据库查询就是数据库里面的左连接&#xff0c;左连接就是两张表执行左关联查询&#xff0c;把左边的表数据全部查询出来。 如图所示我们在进行数据库查询操作时&#xff0c;我们首先需建立数据库连接&#xff0c;输入表名和查询需要的关键字&#xff0c;最后…
阅读更多...
LAMP源码编译安装——CentOS7

LAMP源码编译安装——CentOS7

文章目录 LAMP是什么LAMP软件组件LinuxApacheMySQLPHP 源码安装Apache一、准备工作二、安装环境依赖包三、配置软件模块四、编译及安装五、优化配置文件路径六、添加httpd系统服务&#xff08;有两种方法&#xff09;方法一&#xff1a;方法二&#xff1a; 七、修改httpd 服务配…
阅读更多...
WEB安全：Content Security Policy (CSP) 详解

WEB安全：Content Security Policy (CSP) 详解

Content Security Policy (CSP) 是一种强大的网页安全机制，用于防止跨站脚本 (XSS) 和其他注入攻击。通过设置一系列的内容安全策略，CSP 可以限制网页可以加载的资源，从而保护用户数据和网站的安全性。 什么是 XSS 攻击？ 跨站脚本攻击 (XSS) 是一种常见的安全漏洞，攻击者…
阅读更多...
Svad:一个鲁棒、低功耗、轻量级的语音活动检测与尖峰神经网络

Svad:一个鲁棒、低功耗、轻量级的语音活动检测与尖峰神经网络

SVAD: A ROBUST, LOW-POWER, AND LIGHT-WEIGHT VOICE ACTIVITY DETECTION WITH SPIKING NEURAL NETWORKS 第二章 目标说话人提取之《Svad:一个鲁棒、低功耗、轻量级的语音活动检测与尖峰神经网络》 文章目录 SVAD: A ROBUST, LOW-POWER, AND LIGHT-WEIGHT VOICE ACTIVITY DETE…
阅读更多...
京东二面：Sychronized的锁升级过程是怎样的

京东二面：Sychronized的锁升级过程是怎样的

引言 Java作为主流的面向对象编程语言&#xff0c;提供了丰富的并发工具来帮助开发者解决多线程环境下的数据一致性问题。其中&#xff0c;内置的关键字"Synchronized"扮演了至关重要的角色&#xff0c;它能够确保在同一时刻只有一个线程访问特定代码块或方法&#…
阅读更多...
【Python】 从Python列表中获取唯一值

【Python】 从Python列表中获取唯一值

基本原理 在Python中&#xff0c;列表是一种非常灵活的数据结构&#xff0c;它允许存储不同类型的元素。然而&#xff0c;有时我们可能需要从列表中提取唯一的值&#xff0c;即去除重复的元素。这在处理数据集或进行数据分析时尤其有用。Python提供了几种方法来实现这一目标。…
阅读更多...
[SCTF2019]Who is he

[SCTF2019]Who is he

unity 游戏&#xff0c;直接输入字符串 直接修改 if 判断&#xff0c;看能不能直接输出flag 修改了程序逻辑&#xff0c;但还是输出了 明明已经把这个 if 删了 不知道为什么还会输出这串字符 应该程序还有什么引入吧&#xff0c;看 wp 应该先查一下程序的动态链接库 DLL 是…
阅读更多...
渗透测试工具Cobalt strike-1.CS介绍与配置

渗透测试工具Cobalt strike-1.CS介绍与配置

Cobalt Strike是一款美国Red Team开发的渗透测试神器&#xff0c;常被业界人称为CS。最近这个工具大火&#xff0c;成为了渗透测试中不可缺少的利器。其拥有多种协议主机上线方式&#xff0c;集成了提权&#xff0c;凭据导出&#xff0c;端口转发&#xff0c;socket代理&#x…
阅读更多...
亡羊补牢，一文讲清各种场景下GIT如何回退

亡羊补牢，一文讲清各种场景下GIT如何回退

系列文章目录 手把手教你安装Git&#xff0c;萌新迈向专业的必备一步 GIT命令只会抄却不理解&#xff1f;看完原理才能事半功倍&#xff01; 常用GIT命令详解&#xff0c;手把手让你登堂入室 GIT实战篇&#xff0c;教你如何使用GIT可视化工具 GIT使用需知&#xff0c;哪些操作…
阅读更多...
【ArcGISPro】CSMPlugins文件夹

【ArcGISPro】CSMPlugins文件夹

在ArcGISPro软件的CSMPlugins文件夹含有以下一个应用程序的扩展 从文件的名称可以看出美国地质调查局的太空地质学与ESRI合作进行的一个软件扩展&#xff0c;而USGS主要是遥感影像方向的应该&#xff0c;所以估计该dll的主要功能是多遥感影像进行处理&#xff0c;支持软件的不同…
阅读更多...
MySQL(三)查询

MySQL(三)查询

1、单表和多表查询 1.1 算术运算符、比较运算符及特殊运算符 1)MySQL的算术运算符 select 0.1+0.3333,0.1-0.3333,0.1*0.3333,1/2,1%2; select 1/0,100%0; select 3%2,mod(3,2); 2）MySQL的比较运算符 select 1=0,1=1,null=null; select 1<>0,1<>1,null<&…
阅读更多...
Scala环境的搭建

Scala环境的搭建

要搭建Scala&#xff0c;我们必须先下载java&#xff0c;由于我的电脑已经搭建好了环境&#xff0c;因此我这里用截图来教大家搭建环境。 可以从网上搜索安装包对其进行安装 IntelliJ IDEA – 领先的 Java 和 Kotlin IDE 不建议下载最新版的&#xff0c;大家下载的版本可以下…
阅读更多...
【大宗】第一期：大航海时代下的[集运欧线]

【大宗】第一期：大航海时代下的[集运欧线]

一、大航海时代 - 集运欧线前世今生 01 航运合约指数的诞生 ‍‍‍‍ 2023年8月18日&#xff0c;上海期货交易所的伙伴们搞了个大新闻——他们推出了一种新的期货品种&#xff0c;叫做“欧线集运”。这可不是什么普通的期货&#xff0c;它是基于一个叫做SCFIS的指数&#xf…
阅读更多...
goimghdr，一个有趣的 Python 库！

goimghdr，一个有趣的 Python 库！

更多Python学习内容&#xff1a;ipengtao.com 大家好&#xff0c;今天为大家分享一个有趣的 Python 库 - goimghdr。 Github地址&#xff1a;https://github.com/corona10/goimghdr 在图像处理和分析过程中&#xff0c;识别图像文件的类型是一个常见的需求。Python自带的imghdr…
阅读更多...
DINO结构中的exponential moving average (ema)和stop-gradient (sg)

DINO结构中的exponential moving average (ema)和stop-gradient (sg)

DINO思路介绍 在 DINO 中&#xff0c;教师和学生网络分别预测一个一维的嵌入。为了训练学生模型&#xff0c;我们需要选取一个损失函数&#xff0c;不断地让学生的输出向教师的输出靠近。softmax 结合交叉熵损失函数是一种常用的做法&#xff0c;来让学生模型的输出与教师模型的…
阅读更多...
阿赵UE引擎C++编程学习笔记——GameMode和生命周期

阿赵UE引擎C++编程学习笔记——GameMode和生命周期

大家好&#xff0c;我是阿赵。   之前在介绍HelloWorld的时候&#xff0c;我们很创建了一个MyGameModeBase的c类&#xff0c;然后就可以在BeginPlay函数里面写打印的HelloWorld。这一篇主要是说一下&#xff0c;GameMode究竟是一个什么东西&#xff0c;然后UE里面的生命周期是…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023