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

2023-12-17 06:52
文章标签 线程 方法 相关 同步 机制 终止 状态图

本文主要是介绍线程终止，线程的相关方法，线程状态图以及线程的同步机制。，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

首先我们知道了什么是线程，以及线程的实现方法，接下来我们来了解一下继承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;}@Overridepublic 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 次 hit3.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;@Overridepublic 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 次 hit3.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;@Overridepublic 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());//NEWt.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 {@Overridepublic void run() {while (true) {for (int i = 0; i < 10; i++) {System.out.println("hi " + i + getState());//RUNNABLEtry {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());//NEWt.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 {@Overridepublic void run() {while (true) {for (int i = 0; i < 10; i++) {System.out.println("hi " + i + getState());//RUNNABLEtry {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();// 保证多线程，共享一个对象,这里使用 staticstatic Object o2 = new Object();boolean flag;public DeadLockDemo(boolean flag) {//构造器this.flag = flag;}@Overridepublic void run() {//1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁//2. 如果线程 A 得不到 o2 对象锁，就会 Blocked//3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁//4. 如果线程 B 得不到 o1 对象锁，就会 Blockedif (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.chinasem.cn/article/503483。

相关文章

Feign Client超时时间设置不生效的解决方法

Feign Client超时时间设置不生效的解决方法

《FeignClient超时时间设置不生效的解决方法》这篇文章主要为大家详细介绍了FeignClient超时时间设置不生效的原因与解决方法,具有一定的的参考价值,希望对大家有一定的帮助... 在使用Feign Client时，可以通过两种方式来设置超时时间：1.针对整个Feign Client设置超时时间
阅读更多...
C/C++错误信息处理的常见方法及函数

C/C++错误信息处理的常见方法及函数

《C/C++错误信息处理的常见方法及函数》C/C++是两种广泛使用的编程语言,特别是在系统编程、嵌入式开发以及高性能计算领域,：本文主要介绍C/C++错误信息处理的常见方法及函数,文中通过代码介绍... 目录前言1. errno 和 perror()示例：2. strerror()示例：3. perror(
阅读更多...
CSS去除a标签的下划线的几种方法

CSS去除a标签的下划线的几种方法

《CSS去除a标签的下划线的几种方法》本文给大家分享在CSS中，去除a标签（超链接）的下划线的几种方法，本文给大家介绍的非常详细，感兴趣的朋友一起看看吧... 在 css 中，去除a标签（超链接）的下划线主要有以下几种方法：使用text-decoration属性通用选择器设置：使用a标签选择器，将tex
阅读更多...
C++变换迭代器使用方法小结

C++变换迭代器使用方法小结

《C++变换迭代器使用方法小结》本文主要介绍了C++变换迭代器使用方法小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1、源码2、代码解析代码解析：transform_iterator1. transform_iterat
阅读更多...
C++中std::distance使用方法示例

C++中std::distance使用方法示例

《C++中std::distance使用方法示例》std::distance是C++标准库中的一个函数,用于计算两个迭代器之间的距离,本文主要介绍了C++中std::distance使用方法示例,具... 目录语法使用方式解释示例输出：其他说明：总结std::distance&n编程bsp;是 C++ 标准
阅读更多...
Linux换行符的使用方法详解

Linux换行符的使用方法详解

《Linux换行符的使用方法详解》本文介绍了Linux中常用的换行符LF及其在文件中的表示,展示了如何使用sed命令替换换行符,并列举了与换行符处理相关的Linux命令,通过代码讲解的非常详细,需要的... 目录简介检测文件中的换行符使用 cat -A 查看换行符使用 od -c 检查字符换行符格式转换将
阅读更多...
SpringBoot实现数据库读写分离的3种方法小结

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一：基于AbstractRoutingDataSource实现动态
阅读更多...
Java中的String.valueOf()和toString()方法区别小结

Java中的String.valueOf()和toString()方法区别小结

《Java中的String.valueOf()和toString()方法区别小结》字符串操作是开发者日常编程任务中不可或缺的一部分,转换为字符串是一种常见需求,其中最常见的就是String.value... 目录String.valueOf()方法方法定义方法实现使用示例使用场景toString()方法方法
阅读更多...
Java中List的contains()方法的使用小结

Java中List的contains()方法的使用小结

《Java中List的contains()方法的使用小结》List的contains()方法用于检查列表中是否包含指定的元素,借助equals()方法进行判断,下面就来介绍Java中List的c... 目录详细展开1. 方法签名2. 工作原理3. 使用示例4. 注意事项总结结论：List 的 contain
阅读更多...
macOS无效Launchpad图标轻松删除的4 种实用方法

macOS无效Launchpad图标轻松删除的4 种实用方法

《macOS无效Launchpad图标轻松删除的4种实用方法》mac中不在appstore上下载的应用经常在删除后它的图标还残留在launchpad中，并且长按图标也不会出现删除符号，下面解决这个问... 在 MACOS 上，Launchpad（也就是「启动台」）是一个便捷的 App 启动工具。但有时候，应
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2