29多线程【线程的礼让、合并、中断、守护线程、局部变量共享、线程生命周期】

已于 2024-07-11 15:11:19 修改
阅读量1k 收藏 17
点赞数 27
分类专栏： JavaSE 文章标签： java 开发语言 多线程
于 2024-03-20 18:04:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gangain/article/details/136884559
版权
本文介绍了Java多线程中的线程礼让（Thread.yield）、线程合并（Thread.join）、线程中断（interrupt）以及守护线程的概念，同时探讨了线程局部变量（包括ThreadLocal）的使用和线程生命周期的各个阶段。
摘要由CSDN通过智能技术生成

day29

多线程(剩余部分)

十二、线程的礼让

Thread.yield();

理解：此方法为静态方法，此方法写在哪个线程中，哪个线程就礼让

注意：所谓的礼让是指当前线程退出CPU资源，并转到就绪状态，接着再抢

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次，观察实验结果

随机输出：

A：1
B：1
A：2
B：2
A：3
A：4
…

public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}
public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
			
			//礼让：让当前线程退出CPU资源，当前线程退出后立刻转入抢资源的状态，可能又会抢到CPU资源
			Thread.yield();
		}
	}
}
public class Test01 {
	public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		
		a.start();
		b.start();
	}
}

十三、线程的合并

t.join(); 合并方法

需求：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程

随机输出：（可能情况去理解）

主线程抢到资源直接打印到十，子线程才开始

主线程抢资源到打印到十，子线程也抢到资源打印了一些

主线程抢到资源打印未到十，子线程抢到资源已经打印完

理解图
线程的合并理解图

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <=200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}
public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <=200; i++) {
			System.out.println("主线程：" + i);
			if(i == 10){
				//让t线程加入到当前线程
				t.join();
			}
		}
		
	}
}

十四、线程的中断

线程的中断1
public class MyThread extends Thread{
	@Override
	public void run() {
		while(true){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}
public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		//面试题：下列代码的子线程开启后，是否会在3000毫秒就被销毁？
		//答：不一定，因为3000毫秒后主线程才休眠结束，这时会抢CPU资源
		//	  如果立刻抢到，那么子线程就是3000毫秒后销毁
		//	 如果没有抢到CPU资源，那么子线程会继续运行，直到主线程抢到CPU资源
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		t.stop();//立刻停止（缺点：可能会导致功能缺失）
		//stop()方法已经过时（有个横杠线）
	}
	
}
线程的中断2

线程run()结束就会死，run方法死循环就不会死

用变量flag，防止直接死亡，弥补stop的缺点，线程也有相关的方法

public class MyThread extends Thread{

	private boolean flag = true;
	
	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		while(flag){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}
public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		t.setFlag(false);
		
	}
	
}
线程的中断3

线程也有相关的方法

public class MyThread extends Thread{
	@Override
	public void run() {
		
		//获取线程状态（是否消亡）
//		System.out.println(Thread.currentThread().isInterrupted());
		//输出完才会因为线程状态改变而终止
		while(!Thread.currentThread().isInterrupted()){			
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}
public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		//改变线程状态
		t.interrupt();
	}
	
}

十五、守护线程

守护线程 (后台线程)默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡

注意：垃圾回收器就是守护线程

t.setDaemon(true);

注意：

new出来的都是前台线程

Daemon要在线程启动前设置，不能在线程启动后设置

父类没有抛异常，子类不能抛异常，只能try catch

public class MyThread extends Thread{

	@Override
	public void run() {
		while(true){
			System.out.println("后台线程默默守护着前台线程");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.setDaemon(true);//将当前线程设置为守护线程
		t.start();
		
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
		
	}
}

十六、线程局部变量（实现线程范围内的共享变量）

线程局部变量共享*
理解图

线程局部变量共享理解图

共享单个数据
注意：

A类虽然不是线程类

但是A类的对象在线程中调用了println方法

线程1中的A类对象调用了println方法，那么println方法里的Thread.currentThread()就是获取的是线程1对象

线程2中的A类对象调用了println方法，那么println方法里的Thread.currentThread()就是获取的是线程2对象

public class A {

	public void println(){
		Thread t = Thread.currentThread();
		Integer value = Test01.map.get(t);
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}
//B类同理

public class Test01 {
	public static final ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 10;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}
}
共享多个数据
1.自定义方法解决
public class A {

	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.map.get(t);
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}
//B类同理

//数据包类
public class Data {
	
	private int i;
	private String str;
//有参、无参、get、set、toString方法（略）

}

public class Test01 {
	public static final ConcurrentHashMap<Thread, Data> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data(10,"xxx");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data(20,"yyy");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}
}
2.ThreadLocal

存数据

local.set(data)底层原理：

​ 1.获取当前线程对象

​ 2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>

​ 3.map.put(this,t)

获取数据
local.get()底层原理：
1.获取当前线程对象
2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
3.map.getEntry(this) -> Entry对象
4.entry.getValue()

public class A {

	public void println(){
		Thread t = Thread.currentThread();
		/**
		 * 获取数据
		 * local.get()底层原理：
		 * 		1.获取当前线程对象
		 * 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
		 * 		3.map.getEntry(this) -> Entry对象
		 * 		4.entry.getValue()
		 */
		Data value = Test01.local.get();
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}
//B类同理

//数据包类
public class Data {
	
	private int i;
	private String str;
//有参、无参、get、set、toString方法（略）
	//保证每个线程里只有一个Data包对象
	public static Data getInstance(int i,String str){
		Data data = Test01.local.get();//获取当前线程的Data对象
		if(data == null){
			data = new Data(i, str);
			Test01.local.set(data);
		}else{//有数据就set
			data.setI(i);
			data.setStr(str);
		}
		return data;
	}
}

public class Test01 {
	public static final ThreadLocal<Data> local = new ThreadLocal<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance(10,"xxx");
				
				/**
				 * 存数据
				 * local.set(data)底层原理：
				 * 		1.获取当前线程对象
				 * 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
				 * 		3.map.put(this,t)
				 */
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance(20,"yyy");
				data = Data.getInstance(30,"zzz");
				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}
}

十七、线程的生命周期*

概念

1、新建状态

i. 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。

ii. 例如：Thread thread=new Thread();

2、 就绪状态

i. 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。

3、运行状态

i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

4、 阻塞状态

i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5、死亡状态

i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

线程生命周期图

在这里插入图片描述

程序奇男子
关注
专栏目录
线程合并
村口王大爷的博客
03-07 819
线程合并 合并是指将指定的某个线程加入到当前线程中，合并为一个线程，由先前的两个线程交替执行变成一个线程中的两个子线程按顺序执行。 通过调用join方法来实现合并，具体如何合并? 线程甲和线程乙，线程甲执行到某个时间点的时候调用线程乙的join方法，则表示从当前时间点开始CPU资源被线程乙独占，线程甲进入阻塞状态，直到线程乙执行完毕，线程甲才进入就绪状态，等待获取CPU资源进而进入运行状态。 join方法重载： join方法表示乙线程执行完毕之后才能执行其他线程，join（long millis）表示乙线程
python多线程编程(8):线程的合并和后台线程
weixin_34221112的博客
03-21 172
线程的合并 python的Thread类中还提供了join()方法，使得一个线程可以等待另一个线程执行结束后再继续运行。这个方法还可以设定一个timeout参数，避免无休止的等待。因为两个线程顺序完成，看起来象一个线程，所以称为线程的合并。一个例子： import threadingimport randomimport timeclass MyThread(threading.Threa...
【多线程】线程停止、休眠、礼让、执行
最新发布
菜鸟的学习笔记
08-07 660
阻塞状态：当调用sleep、wait或同步锁定时，线程进入锁定状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度执行。就绪状态：当调用start()方法，线程理级进入就绪状态，但不意味着理级调度执行。Join合并线程，待此线程执行完之后，再执行其他线程，其他线程阻塞。dead:线程中断或者结束，一旦进入死亡状态，就不能再次启动。运行状态：进入运行状态，线程才正正执行线程体得代码块。礼让线程，让当前正在执行的线程暂停，但不阻塞。sleep时间达到后线程进入就绪状态。
Java_基础_多线程_线程礼让
ljlCSDNnumber的博客
01-24 214
线程礼让 1.礼让线程，让当前正在执行的线程暂停，但不阻塞。 2.将线程从运行状态转为就绪状态。 3.让cpu重新调度，礼让不一定成功！看cpu心情。 代码实例 //测试礼让线程 //礼让不一定成功 public class TestThreadYield { public static void main(String[] args) { MyYield myYield = new MyYield(); new Thread(myYield,"A").st
线程礼让Yield
LIAO_YUANLONG的博客
12-07 132
礼让线程，让当前正在执行的线程暂停，但不阻塞 将线程从运行状态转为就绪状态 让cpu重新调度，礼让不一定成功，看CPU心情 测试线程礼让 礼让不一定成功，看CPU心情 public class TestYield { public static void main(String[] args) { MyYield myYield = new MyYield(); new Thread(myYield,"a").start(); new Thre.
Java基础——多线程
qq_45821255的博客
04-14 661
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Java基础——多线程前言一、线程概述1.什么是进程和线程？2.什么是并行和并发？二、多线程的实现1.继承Thread实现多线程2.Runnable接口实现多线程3.总结 前言 提示：这里可以添加本文要记录的大概内容： 一、线程概述 1.什么是进程和线程？ 进程是指一个内存中的运行程序。每个进程都有一块自己独立的内存空间，一个进程中可以启动一个或多个线程。 线程是指进程中的一个执行流程，线程是由进程创建的，它是进程的一个实体。一个进.
多线程基础
m0_54108654的博客
04-16 804
目录 一 线程相关概念 1 程序 2 进程 3 线程 4 单线程 5 多线程 6 并发——交替运行 7 并行——同时运行 二 线程的基本使用 1 创建线程的两种方式 2 线程应用案例1—继承Thread类 3 线程应用案例2—实现Runnable接口 4 线程应用案例3——多线程执行 5 两种创建线程方式的区别 一 线程相关概念 1 程序 定义：是为了完成特定任务，用某种语言编写的一组指令集合 简单的说：就是我们些的代码 2 进程 21 进程就是运行的程序，程序一
多线程高并发,这一篇你就进阶了
hotcsawp的博客
05-17 1216
多线程高并发等工具类，从源码理解原理
线程、多线程和线程池面试专题
程序员Android
08-30 101
极力推荐文章：欢迎收藏Android 干货分享和您一起终身学习，这里是程序员Android1、开启线程的三种方式？1）继承Thread类，重写run()方法，在run(...
线程合并 （join）
喻志强的博客
06-13 1013
上一篇： 从Java线程到kotlin协程之线程休眠 （sleep） 线程合并（join） 将指定的线程加入到当前线程，当前线程会处于 WAITING 状态，直到引用的线程死亡（出现异常或者执行完毕），然后当前线程再继续执行。 先来看看join方法源码 可以看到，join调用了另外一个重载的方法，我们再看看重载的那个方法。 可以看到，join方法最终调用的是一个同步方法，接收一个毫秒值。 我们来简单用一用： 有以下代码 public static void main(String[] args
Java线程：线程的调度-合并
蜜蜂的专栏
05-31 239
Java线程：线程的调度-合并   线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。   join为非静态方法，定义如下： void join()         等待该线程终止。     void join(long millis)         等待该线程终止的时间最长为 mi
我之见--线程合并
08-17 698
今天我们主要来学习
java 多线程合并_Java多线程-线程的调度(合并)
weixin_31695145的博客
02-16 401
线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。join为非静态方法，定义如下：void join(): 等待该线程终止。void join(long millis): 等待该线程终止的时间最长为 millis 毫秒。void join(long millis, int nanos): 等待该线程终止的时间...
礼让线程
weixin_30824277的博客
02-17 340
礼让线程 yield让出cpu package com.loaderman.threadmethod; public class Demo_Yield { /** * yield让出cpu礼让线程 */ 　　public static void main(String[] args) { 　　　　new MyThread().start(); ...
java 线程合并
loopxu的专栏
12-06 391
package com.jshan; import java.util.HashMap; import java.util.Map; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.Callable; import java.util.concurrent.CyclicBarrier; ...
线程礼让
村口王大爷的博客
03-08 271
线程礼让 线程礼让是指在某个特定的时间点，让线程暂停抢占CPU资源的行为，运行状态/就绪状态–》阻塞状态，将CPU资源让给其他的线程来使用。 假如线程甲和线程乙在交替执行，某个时间点线程甲做出了礼让，所以在这个时间点线程乙拥有了CPU资源，执行业务逻辑，但不代表线程甲一直暂停执行。 线程甲只是在特定的时间点礼让，过了时间节点，线程甲再次进入就绪状态，和线程乙争夺CPU资源。 通过yield方法来实现。 package com.mie.yield; public class YieldThread1 ex
Python多线程与变量共享深度解析
总结来说，Python多线程提供了并发执行任务的能力，但要注意线程安全问题，尤其是在修改共享变量时。使用锁是一种有效的解决策略，可以避免竞态条件并确保数据一致性。在实际开发中，正确理解和使用多线程及同步机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值