线程终止，线程的相关方法，线程状态图以及线程的同步机制。

news2024/10/5 18:29:35

首先我们知道了什么是线程，以及线程的实现方法，接下来我们来了解一下继承Thread类和Runnable接口的区别，其实本质上是没有区别的，因为Thread也实现了Runnable的接口，唯一区别就是使用Runnable接口，可以实现多个线程共享一个资源的情况，而且不会受到单继承的限制，这里我们建议使用Runnable接口。

我们再来聊一下线程终止的操作，线程终止顾名思义就是想让进程停止运行，我们可以通过设置变量的方法来使线程退出，即通知方式，这里我们用一个实例来进行演示：

public class ift {
    public static void main(String[] args) {
        Preson2 preson2 = new Preson2(true);
        Thread thread = new Thread(preson2);
        thread.start();

        for (int i = 0; i < 10; i++){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hi~");
            if (i == 5){
                preson2.setf(false);
            }
        }

    }
}

class Preson2 implements Runnable{
    public Boolean b;

    public Preson2(Boolean b) {
        this.b = b;
    }

    @Override
    public void run() {
        while(b){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello~");

        }
    }


    public void setf(Boolean b){
        this.b = b;
    }
}

 

这里我们发现hello只被执行了五次，是因为我们在主线程中设定了终止信息，才实现了该功能；

线程还有一系列的相关方法：

这是线程的常用方法，我们就不一一列举了。

这里提示一下：interrupt方法并不是中断一个线程的运行，而是让正在休眠的线程提前中断休眠，让它重新运作。

这里有俩个非常常用的方法一个是yield：线程的礼让，一个是join：线程插队，线程的礼让：让出cpu，给其他线程先运行，但是会根据cpu的运行状态来确定，如果cpu的资源很丰富则不会礼让成功，所以线程礼让是不确定的，它不一定会成功，线程插队：线程插队跟线程礼让不同，它比较霸道，一旦插队成功是必须先执行完该线程，才会将cpu让出来给其他线程使用。

join方法：

public class ift {
    public static void main(String[] args) {
        Thread t3 = new Thread(new T3());//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//说明主线程输出了 5 次 hi
                t3.start();//启动子线程 输出 hello... t3.join();//立即将 t3 子线程，插入到 main 线程，让 t3 先执行
                try {
                    t3.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(1000);//输出一次 hi, 让 main 线程也休眠 1s
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

}


class T3 implements Runnable{
    private int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

 

yield方法：

public class ift {
    public static void main(String[] args) {
        Thread t3 = new Thread(new T3());//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//说明主线程输出了 5 次 hi
                t3.start();//启动子线程 输出 hello... t3.join();//立即将 t3 子线程，插入到 main 线程，让 t3 先执行
                t3.yield();
            }
            try {
                Thread.sleep(1000);//输出一次 hi, 让 main 线程也休眠 1s
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

}


class T3 implements Runnable{
    private int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

 

这里我们发现并没有礼让成功而是交替输出。

接下来我们看一下线程的状态图：
  

Runnable状态在jvm机中又被分为ready和running两个状态。

我们可以通过getState()这个方法来查询线程的当前状态，我们写个实例来看一下：

public class ift {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());//NEW
        t.start();
        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());//TIMED_WAITING,原因线程每运行一次就休眠一秒钟
            Thread.sleep(500);
        }
        System.out.println(t.getName() + " 状态 " + t.getState());//TERMINATED
    }
}
class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i + getState());//RUNNABLE
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}
while (Thread.State.TERMINATED != t.getState()) {
    System.out.println(t.getName() + " 状态 " + t.getState());//TIMED_WAITING,原因线程每运行一次就休眠一秒钟
    Thread.sleep(500);
}

该循环内大家肯定有疑问，为什么一直都是TIMED_WAITING状态，为什么刚启动后的RUNNABLE状态打印不了，那是因为运行的过程很快可能就几毫秒，所以根本捕捉不到该状态，但是休眠的时间很长所以打印的都是休眠的状态，运行状态可以在它运行的时候一块打印出来，就像我写的一样，给大家看一下结果：

当我们休眠状态足够短的时候我们发现状态就会发生变化：

public class ift {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());//NEW
        t.start();
        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());//TIMED_WAITING,原因线程每运行一次就休眠一秒钟
            Thread.sleep(2);
        }
        System.out.println(t.getName() + " 状态 " + t.getState());//TERMINATED
    }
}
class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i + getState());//RUNNABLE
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

 

接下来我们来学习一下线程的同步机制：什么是线程的同步机制我们先来看一个实例来引出线程同步机制的作用：

public class Tick {
    public static void main(String[] args) {
        sellTcik sellTcik = new sellTcik();
        new Thread(sellTcik).start();
        new Thread(sellTcik).start();
        new Thread(sellTcik).start();
    }

}

class sellTcik implements Runnable{

    @SuppressWarnings({"all"})
    public int tick = 100;
    Object object = new Object();
    private Boolean loop = true;
    public void run(){
        while(loop){
            m();
        }
    }
    public void m(){

        if (tick == 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        System.out.println("线程" + Thread.currentThread().getName() + "     " + (--tick));
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }
}

当我们运行代码的时候我们就会发现一些问题：

它的票数可能出现负数的情况，这是为什么呢，这是因为它是三个线程一块进入进行操作的，假如票还有两张，三个线程一块进去检测票数确实大于0，所以会直接拿去卖，买了三张，所以出现 了超票的情况，那我们怎么来解决这样的情况呢，这里就要用到我们的线程同步机制了，它的实现方法是synchronized（），括号内可以添加一个对象，相当于一把锁，只有拿到锁的线程才能进入我们的方法中，但是听起来效率会大大降低，线程的深入学习，以后会进行讨论，我们先来了解目前学习的方法，而且这个锁，有个特点，它对于线程而言必须指向的同一个对象，如果是不同对象，那该锁则是无效的，这里我们使用接口类中的Object类型的对象，因为实现Runnable接口只需要创建一个对象即可，如果我们用的是继承Thread的方法时，我们需要创建多个对象，这是我们可以将Object类型设置为静态属性这里可以给多线程共享相同的资源。所以object对象肯定是相同对象（synchronized（）被该方法框起来的代码越少越好，可以提升效率）。

public class Tick {
    public static void main(String[] args) {
        sellTcik sellTcik = new sellTcik();
        new Thread(sellTcik).start();
        new Thread(sellTcik).start();
        new Thread(sellTcik).start();
    }

}

class sellTcik implements Runnable{

    @SuppressWarnings({"all"})
    public int tick = 100;
    Object object = new Object();
    private Boolean loop = true;
    public void run(){
        while(loop){
            m();
        }
    }
    public void m(){
        synchronized (object) {
            if (tick == 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }
            System.out.println("线程" + Thread.currentThread().getName() + "     " + (--tick));
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

如果设置同步方法

public synchronized static void m1() {
}
它默认的锁就是该类的类名.class

这里我们发现超票的问题得到了很好的解决。（同步机制的互斥锁大多设置为自己的类即类名.class)，该锁是必然有效的，因为类只能有一个，可以根据自己的喜好，自行添加锁。

互斥锁：

互斥锁的特征就像上述所说，只允许一个线程拿到锁，等到该线程运行完才能让其他线程进入，而且互斥锁，必须指向的同一对象，如果不同对象进入拿到的锁不同，则无法做到限制的作用，则该锁无效。

线程死锁：

我们直接模拟死锁给大家一个直观的感受：

public class Tick {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();
    }

}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
    static Object o2 = new Object();
    boolean flag;
    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }
    @Override
    public void run() {
        //1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
        //3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

 

我们发现A，B两线程都处于了Blocked状态，这就是死锁，互相拿着对方需要的锁，无法继续往下运行。

 

 

 

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

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

相关文章

准确无误的二手车估值API接口，帮您把握市场行情！

准确无误的二手车估值API接口，帮您把握市场行情！

随着二手车市场的快速发展&#xff0c;越来越多的人开始关注二手车的估值问题。在购买二手车或者出售二手车时&#xff0c;了解车辆的真实价值是非常重要的。而准确无误的二手车估值API接口能够帮助我们更好地把握市场行情。 在挖数据平台上&#xff0c;我们提供了一个功能强大…
阅读更多...
IntersectionObserver API的简单介绍及应用

IntersectionObserver API的简单介绍及应用

前言 IntersectionObserver 之前就有所了解&#xff0c;但是一直没有用&#xff0c;当时觉得浏览器兼容性不好&#xff0c;直接用onscroll监听也能实现相关功能&#xff0c;但是随着浏览器支持性越来越好&#xff0c;这个属性到迄今为止&#xff0c;可以用在大部分的正式项目中…
阅读更多...
C++泛型超详细合集-泛化的编程方式-程序员编写一个函数/类的代码让编译器去填补出不同的函数实现-供大家学习研究参考

C++泛型超详细合集-泛化的编程方式-程序员编写一个函数/类的代码让编译器去填补出不同的函数实现-供大家学习研究参考

以Add函数为例&#xff0c;在函数模板存在的同时&#xff0c;我们还可以单独写一个int类型的add函数。这都归功于函数重载的存在。 同时&#xff0c;我们还可以使用<int>来指定函数模板重载为已存在的Add函数。因为本质上这两个函数是不同的&#xff0c;并不会冲突。 下…
阅读更多...
代码随想录27期|Python|Day16|二叉树|104.二叉树的最大深度|111.二叉树的最小深度|222.完全二叉树的节点个数

代码随想录27期|Python|Day16|二叉树|104.二叉树的最大深度|111.二叉树的最小深度|222.完全二叉树的节点个数

二叉树专题&#xff0c;重点掌握后续的递归和中间节点的处理。 104. 二叉树的最大深度 - 力扣&#xff08;LeetCode&#xff09; 本题在前一章已经解决了层序遍历的解法&#xff0c;现在来聊一下递归法。 首先需要明确两个概念&#xff1a;深度和高度。&#xff08;注意&…
阅读更多...
千亿露酒市场的未来之“露”

千亿露酒市场的未来之“露”

执笔 | 尼 奥 编辑 | 扬 灵 12月15日&#xff0c;以“以美为酿&#xff0c;品致未来”为主题的中国露酒产业发展大会暨露酒价值论坛在“中国酒都”宜宾举办。 近年来&#xff0c;露酒产业发展异军突起&#xff0c;市场销售规模超越黄酒、葡萄酒品类&#xff0c;成为中国酒…
阅读更多...
Ubuntu系统入门指南：基础操作和使用

Ubuntu系统入门指南：基础操作和使用

Ubuntu系统的基础操作和使用 一、引言二、安装Ubuntu系统三、Ubuntu系统的基础操作3.1、界面介绍3.2、应用程序的安装和卸载3.3、文件管理3.4、系统设置 四、Ubuntu系统的日常使用4.1、使用软件中心4.2、浏览器的使用和网络连接设置4.3、邮件客户端的配置和使用4.4、文件备份和…
阅读更多...
大数据与深度挖掘：如何在数字营销中与研究互动

大数据与深度挖掘：如何在数字营销中与研究互动

数字营销最吸引人的部分之一是对数据的内在关注。 如果一种策略往往有积极的数据&#xff0c;那么它就更容易采用。同样&#xff0c;如果一种策略尚未得到证实&#xff0c;则很难获得支持进行测试。 数字营销人员建立数据信心的主要方式是通过研究。这些研究通常分为两类&…
阅读更多...
人工智能文本分类

人工智能文本分类

在本文中&#xff0c;我们全面探讨了文本分类技术的发展历程、基本原理、关键技术、深度学习的应用&#xff0c;以及从RNN到Transformer的技术演进。文章详细介绍了各种模型的原理和实战应用&#xff0c;旨在提供对文本分类技术深入理解的全面视角。 一、引言 文本分类作为人工…
阅读更多...
java集合的迭代器与遍历

java集合的迭代器与遍历

文章目录 迭代器Iterator1、什么是Iterator2&#xff0c;iterator接口的API3、Irerator()方法细节解释4. Irerator的原理示意图4. 1 Irerator的案例5. forEach循环与Iterator遍历的区别与联系 ListIterator1.ListIterator的概述(1) 概念(2) 解析 2.ListIterator的生成3.ListIte…
阅读更多...
微服务实战系列之ZooKeeper（下）

微服务实战系列之ZooKeeper（下）

前言 通过前序两篇关于ZooKeeper的介绍和总结&#xff0c;我们可以大致理解了它是什么&#xff0c;它有哪些重要组成部分。 今天&#xff0c;博主特别介绍一下ZooKeeper的一个核心应用场景&#xff1a;分布式锁。 应用ZooKeeper Q&#xff1a;什么是分布式锁 首先了解一下&…
阅读更多...
AMD 自适应和嵌入式产品技术日

AMD 自适应和嵌入式产品技术日

概要 时间&#xff1a;2023年11月28日 地点&#xff1a;北京朝阳新云南皇冠假日酒店 主题内容&#xff1a;AMD自适应和嵌入式产品的更新&#xff0c;跨越 云、边、端的AI解决方案&#xff0c;赋能智能制造的机器视觉与机器人等热门话题。 注&#xff1a;本文重点关注FPGA&a…
阅读更多...
10-流媒体-RTMP编译

10-流媒体-RTMP编译

将h264推流给服务器&#xff0c;就完成了采集端的推流工作。一般在嵌入式系统常用的rtmp推流方案是rtmpdump。使用rtmp库涉及到一些编译过程&#xff0c;下面我们一点点描述。 关于rtmp的使用涉及到3个开源库的编译&#xff08;openssl, zlib, rtmpdump&#xff09;&#xff0c…
阅读更多...
ACL和NAT

ACL和NAT

目录 一.ACL 1.概念 2.原理 3.应用 4.种类 5.通配符 1.命令 2.区别 3.例题 4.应用原则 6.实验 1.实验目的 2.实验拓扑 3.实验步骤 7.实验拓展 1.实验目的 2.实验步骤 3.测试 二.NAT 1.基本理论 2.作用 3.分类 静态nat 动态nat NATPT NAT Sever Easy-IP…
阅读更多...
【FPGA/verilog -入门学习11】verilogTestbench中的文本文件写入，读出，打印等操作

【FPGA/verilog -入门学习11】verilogTestbench中的文本文件写入，读出，打印等操作

本文参考&#xff1a;Verilog中的系统任务&#xff08;显示/打印类&#xff09;--$display&#xff0c; $write&#xff0c;$strobe&#xff0c;$monitor-CSDN博客 Verilog&#xff1a;parameter、localparam的区别和用法-CSDN博客 Verilog的系统任务----$fopen、$fclose和$fd…
阅读更多...
SQL Server 远程连接服务器数据库

SQL Server 远程连接服务器数据库

本文解决sql server的远程连接问题。需要开启防火墙&#xff0c;开启端口&#xff0c;并处理权限不足的报错: 【use 某数据库】The server principal "[server]" is not able to access the database "[database]" under the current security context. 【…
阅读更多...
SCI一区级 | Matlab实现GWO-CNN-GRU-selfAttention多变量多步时间序列预测

SCI一区级 | Matlab实现GWO-CNN-GRU-selfAttention多变量多步时间序列预测

SCI一区级 | Matlab实现GWO-CNN-GRU-selfAttention多变量多步时间序列预测 目录 SCI一区级 | Matlab实现GWO-CNN-GRU-selfAttention多变量多步时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 1.Matlab实现GWO-CNN-GRU-selfAttention灰狼算法优化卷积门控循环…
阅读更多...
【接口技术】课堂word补充习题和讲解（乱序）

【接口技术】课堂word补充习题和讲解（乱序）

DAC & ADC 1&#xff1a;B 梯形电阻网络中的电阻是R和2R&#xff0c;只用了2种阻值 2&#xff1a;B LSBFSR/(2^n)5V / 2^10 5V / 1024 0.0048828125V 4.883mV 3&#xff1a;输入寄存器、DAC寄存器、D/A转换器 如下图所示 中断向量表&#xff0c;CSIP 多个元件互连的例题…
阅读更多...
2023年12月5日，北京elastic Meetup 腾讯分享的搜索优化经验

2023年12月5日，北京elastic Meetup 腾讯分享的搜索优化经验

1、减少长文本模糊匹配&#xff0c;降低 CPU 大量分词上的开销 长文本全文查询由于在查询时需要进行分词处理&#xff0c;因此在查询并发较大的情况下&#xff0c; cpu会先于IO被打满&#xff0c;从而出现大量的查询拒绝。 2、设置多副本提高并发和均衡单节点压力 Search查询请…
阅读更多...
Linux访问MySQL数据库（包含实验案例）

Linux访问MySQL数据库（包含实验案例）

1、访问MySQL数据库。 1.1、登录到MySQL服务器 经过安装后的初始化过程&#xff0c;MySQL数据库的默认管理员用户名为"root"&#xff0c;密码为空。 [rootyang ~]# mysql -u root //"-u"选项用于指定认证用户有密码的情况下&#xff0c;使用"-p&qu…
阅读更多...
【OpenCV】 OpenCV 源码编译并实现 CUDA 加速 (Windows)

【OpenCV】 OpenCV 源码编译并实现 CUDA 加速 (Windows)

OpenCV 源码编译并实现 CUDA 加速 Windows 1. 环境准备1.1 软件环境1. 2 源码下载 2. CMake编译项目2.1 创建cmake项目2.2 设置编译配置2.3 解决异常2.3.1 文件下载异常2.3.2 解决CUDA版本异常 2.4 编译项目 3. Visual Studio 编译项目4. 项目测试5. 总结 OpenCV是一个基于Apac…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023