【Java 语言】Java 多线程 一 ( 线程基础 : 线程启动 | 线程停止 | 线程暂停 | 线程优先级 | 守护线程)

最新推荐文章于 2023-04-23 21:36:11 发布
最新推荐文章于 2023-04-23 21:36:11 发布
阅读量3.5k 收藏 15
点赞数 2
分类专栏： java 文章标签： 线程停止
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shulianghan/article/details/52369486
版权





一. 线程启动




线程启动 : 

-- 1. 继承 Thread 运行线程 : 重写 Thread 类的 run 方法, 然后执行该线程;

-- 2. 实现 Runnable 接口, 并运行线程;

-- 代码示例 : 

package com.hanshuliang.thread;

public class ThreadStart {

	public static void main(String[] args) {
		//1. 继承 Thread 运行线程
		MyThread thread = new MyThread();
		thread.start();
		
		//2. 实现 Runnable 接口, 并运行线程
		Thread runnableThread = new Thread(new MyRunnable());
		runnableThread.start();
	}
	
	//1. 继承 Thread 类
	static class MyThread extends Thread{
		@Override
		public void run() {
			super.run();
			System.out.println("MyThread 线程启动");
		}
	}
	
	//2. 实现 Runnable 接口
	static class MyRunnable implements Runnable{
		@Override
		public void run() {
			System.out.println("MyRunnable 线程启动");
		}
	}
}


-- 运行结果 : 

MyThread 线程启动
MyRunnable 线程启动




三. 线程停止



线程停止常用方法 : 

-- 1. 使用 interrupt() 方法停止线程;

-- 2. 使用退出标志, 让线程正常退出;

-- 3. 弃用的方法 (不推荐) : 使用 stop() 方法强制停止线程, 但是该方法已经作废, 不建议使用;


1. 使用 interrupt() 方法停止线程


(1) 线程无法立即停止



interrupt() 使用说明 : 

-- 打标记 : 调用该方法, 不能马上停止该线程, 只是在当前线程打了一个停止标记;


代码示例 : 

-- 代码 : 

public class InterruptDemo {
	public static class MyThread extends Thread {
		@Override
		public void run() {
			super.run();
			for (int i = 1; i <= 1000000; i++)	//打印 一百万 数字, 大概持续 5 ~ 10 秒左右
				System.out.println(i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();
		thread.start();						//启动线程
		Thread.sleep(100);					//启动线程 100ms 后中断线程
		thread.interrupt();					//中断线程
	}
}


-- 运行结果 : 这里只贴上最后几行 命令行的运行结果;

... ...
999996
999997
999998
999999
1000000


-- 总结 : 在上述程序中, 打印了 100 万数字, 从 1 到 100 0000, 整个过程持续了 10秒左右, 但是我们在 线程开始后 100ms 就中断了线程, 但是线程还是执行完毕了, 说明线程并没有在调用 interrupt() 方法后立即停止;




(2) 线程停止状态判定



两个线程停止状态判定的方法 : 

-- 1. interrupted() 方法 : ①判断当前线程的中断标志, ②如果是中断标志 true, 那么清除中断标志, 改为 false;,③ 连续两次调用该方法, 第二次返回 false, ④ 静态方法 : 该方法是测试当前线程的中断标志, 在哪个线程中调用, 就是判定的哪个线程的中断标志, 不管调用的主体是哪个线程;

-- 2. isInterrupted() 方法 : 判断线程的 中断状态, 不管真实的运行状态, 只关心状态;

-- 注意 : 两个方法都是判断 中断状态的, 与线程的真实运行状况无关;



(3) interrupted() 方法测试



interrupted () 方法测试1 : 测试 interrupted 方法的判断是否已经中断的效果;

-- 测试代码 : 

public class InterruptedDemo1 {
	public static class MyThread extends Thread {
		@Override
		public void run() {
			super.run();
			for (int i = 1; i <= 10; i++)	//打印10个数字
				System.out.println(i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();
		thread.start();						//启动线程
		thread.interrupt();					//启动线程后马上 中断线程
		
		System.out.println("第一次 : thread.interrupted() = " + thread.interrupted());
		System.out.println("第二次 : thread.interrupted() = " + thread.interrupted());
	}
}


-- 执行结果 : 

第一次 : thread.interrupted() = false
1
2
第二次 : thread.interrupted() = false
3
4
5
6
7
8
9
10


-- 总结 : 启动线程后, 立即调用 interrupt 方法 中断线程, 但是 在主线程中 调用 thread.Interrupted() 方法, 打印出来的是 主线程的中断状态标志, 虽然是调用的 thread 子线程的对象的方法, 但是该方法是一个静态方法, 在哪个线程调用, 就是打印哪个线程的中断标志;



interrupted () 方法测试2 : 测试 interrupted 方法的 清除 中断状态 的效果;

-- 1. 测试代码 : 

public class InterruptedDemo {
	public static void main(String[] args) throws InterruptedException {
		Thread.currentThread().interrupt(); 	//中断主线程
		
		System.out.println("第一次 : thread.interrupted() = " + Thread.interrupted());
		System.out.println("第二次 : thread.interrupted() = " + Thread.interrupted());
	}
}


-- 2. 执行结果 : 

第一次 : thread.interrupted() = true
第二次 : thread.interrupted() = false


-- 3. 总结 : 使用 interrupted() 方法, 如果当前线程的状态是中断状态, 即返回了 true, 那么需要清除该标志, 下一次调用 interrupted() 方法后, 返回值就是 false 了;



(4) isInterrupted() 方法测试



isInterrupted() 方法测试1 : 测试其 中断状态, 与上面的 interrupted() 方法对比;

-- 1. 测试代码 : 

public class IsInterruptedDemo {
	public static class MyThread extends Thread {
		@Override
		public void run() {
			super.run();
			for (int i = 1; i <= 10; i++)	//打印10个数字
				System.out.println(i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();
		thread.start();						//启动线程
		thread.interrupt();					//启动线程后马上 中断线程
		
		System.out.println("第一次 : thread.interrupted() = " + thread.isInterrupted());
		System.out.println("第二次 : thread.interrupted() = " + thread.isInterrupted());
	}
}


-- 2. 返回值 : 

第一次 : thread.interrupted() = true
1
2
第二次 : thread.interrupted() = true
3
4
5
6
7
8
9
10


-- 3. 总结分析 : isInterrupted() 方法 只 判断 被调用对象的 该对象线程的 线程的中断 状态, 不管线程的真实运行状况, 即使当前线程正在运行, 但是线程调用了 interrupt() 方法, 其中断状态为 true, 因此 isInterrupted() 方法的返回值一直是 true;

-- 4. 对比 interrupted() 方法 : interrupted() 方法反应的是真实的线程运行状态, 线程正在运行, 那么返回 false, 如果线程没有运行, 返回 true;

-- 5. 对比 Interrupted() 方法 (静态与普通方法) : isInterrupted 方法是非静态方法, 哪个对象调用返回的就是哪个对象的中断状态; interrupted 是静态方法, 在哪个线程调用就是返回哪个线程的中断状态;




2. 异常法停止线程


(1) 线程循环中正常退出停止



退出方法 : 正常退出线程;

-- 1. 前提 : 线程中执行一个循环;

-- 2. 中断线程 : 执行线程中断操作, 调用 线程的 interrupt() 方法;

-- 3. 查询中断标志 : 在线程中通过调用 interrupted 方法, 查询当前的线程中断标志, 之后该方法就会将中断标志清除;

-- 4. 退出循环 : 如果查询到中断标志后, 直接使用 break 退出循环;

-- 5. 弊端 : 在线程中, 线程没有真正的停止, 线程还是完整的执行了;


线程正常退出代码示例 : 

-- 1. 代码 : 

public class ExceptionInterruptDeo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			super.run();
			for(int i = 0; i < 500; i ++){
				if(interrupted()){				//判断线程的中断状态, 如果中断直接 break
					System.out.println("停止状态, 退出");
					break;
				}
				System.out.println(i);
			}
			System.out.println("MyThread 线程执行完毕");//线程结束标志
		}
	}
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();		//创建线程并执行
		thread.start();							//启动线程
		Thread.sleep(1);						//沉睡 1 毫秒
		thread.interrupt();						//中断线程
		System.out.println("主线程执行完毕");	//判断主线程停止
	}
}


-- 2. 执行结果 : 

... ...
50
51
52
53
54
主线程执行完毕
停止状态, 退出
MyThread 线程执行完毕


-- 3. 总结分析 : 在线程中调用 interrupted() 方法, 查询中断标志(查询后立即清除中断标志), 弊端是停止线程后, 线程还是继续执行后面的逻辑, 继续执行完毕, 自动退出的;



(2) 异常退出线程



异常法退出线程 : 通过抛出一个异常, 来终止线程执行;

-- 1. 前提 : 线程中执行一个循环;

-- 2. 中断线程 : 执行线程中断操作, 调用 线程的 interrupt() 方法;

-- 3. 查询中断标志 : 在线程中通过调用 interrupted 方法, 查询当前的线程中断标志, 之后该方法就会将中断标志清除;

-- 4. 抛出异常退出循环 : 如果查询到中断标志后, 直接抛出一个 InterruptException 异常;

-- 5. 捕获处理异常 : 要将整个 run 方法中的内容使用 try catch 代码块捕获, 因因为异常捕获后还会继续处理 try catch 之后的代码逻辑, 如果 try catch 代码块之后还有代码逻辑, 程序还会执行这段代码;

-- 6. 好处 : 可以自由控制要中断哪些逻辑;


异常捕获规则 : 

-- 1. 执行逻辑 : 捕获异常后, 进行异常处理, 然后会继续执行 try catch 代码块 后面的代码逻辑;

-- 2. 异常退出范围可控 : 可以自由控制中断哪些操作, 继续执行哪些操作;


代码测试 : 

-- 1. 代码 : 

public class ExceptionInterruptDeo {
	public static class MyThread extends Thread {
		@Override
		public void run() {
			try {
				super.run();
				for (int i = 0; i < 500; i++) {
					if (interrupted()) { // 判断线程的中断状态, 如果中断直接 break
						System.out.println("停止状态, 抛出异常退出");
						throw new InterruptedException();
					}// 中断标志 判定结束
					System.out.println(i);
				}//for 循环结束
				System.out.println("MyThread 线程执行完毕");// 线程结束标志
			} catch (InterruptedException e) {
				System.out.println("线程中捕获异常代码块");
				e.printStackTrace();
			} // try catch 代码块
		}//run方法结束
	}//线程结束

	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread(); // 创建线程并执行
		thread.start(); // 启动线程
		Thread.sleep(1); // 沉睡 1 毫秒
		thread.interrupt(); // 中断线程
		System.out.println("主线程执行完毕"); // 判断主线程停止
	}
}


-- 2. 执行结果 : 

113
114
115
116
主线程执行完毕
停止状态, 抛出异常退出
线程中捕获异常代码块
java.lang.InterruptedException
	at base.ExceptionInterruptDeo$MyThread.run(ExceptionInterruptDeo.java:12)


-- 3. 总结分析 : 在 run 方法中将整个代码逻辑使用 try catch 代码块包裹, 异常法只能中断 try catch 代码块中的逻辑;




3. sleep() 中停止线程


(1) 先沉睡在终止线程



先 sleep() 再 interrupt() : 先沉睡, 再终止线程, 线程直接就停止了;


代码示例 : 

-- 1. 代码 : 

public class SleepInterruptDemo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			try {
				System.out.println("线程逻辑开始");
				super.run();
				sleep(1000);	//启动后立即进入沉睡状态, 沉睡 1000ms
				System.out.println("线程逻辑结束");
			} catch (InterruptedException e) {
				System.out.println("捕获到了异常 , 进入了 catch 代码块");
				e.printStackTrace();
			}//catch代码块
			System.out.println("run 方法结束");
		}//run方法
	}//线程
	
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();	//新建线程
		thread.start();						//线程启动
		Thread.sleep(100);					//沉睡 100 毫秒, 线程中
		thread.interrupt();					//中断线程
	}
}


-- 2. 执行结果 : 

线程逻辑开始
捕获到了异常 , 进入了 catch 代码块
run 方法结束
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:11)


-- 3. 总结分析 : 在沉睡状态下, 如果调用 interrupt() 方法, 线程中会直接抛出 InterruptException 异常;



(2) 先终止线程 再 沉睡



先 终止线程 再 sleep : 先 终止线程, 在 sleep, 那么 sleep 之前的代码需要实现相关逻辑


代码示例 : 

-- 1. 代码 : 与上面的区别是 在 sleep 之前有一段 循环逻辑;

public class SleepInterruptDemo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			try {
				System.out.println("线程逻辑开始");
				super.run();
				for(int i = 0; i < 500; i ++)
					System.out.println(i);
				sleep(1000);	//启动后立即进入沉睡状态, 沉睡 1000ms
				System.out.println("线程逻辑结束");
			} catch (InterruptedException e) {
				System.out.println("捕获到了异常 , 进入了 catch 代码块");
				e.printStackTrace();
			}//catch代码块
			System.out.println("run 方法结束");
		}//run方法
	}//线程
	
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();	//新建线程
		thread.start();						//线程启动
		thread.interrupt();					//中断线程
		System.out.println("主线程中断线程");
	}
}


-- 2. 执行结果 : 

496
497
498
499
捕获到了异常 , 进入了 catch 代码块
run 方法结束
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:12)


-- 3. 总结 : 使用 Interrupt 方法后, 如果正在执行循环, 就不会抛异常退出线程, 进入 sleep 状态后, 会立即抛出异常, 退出线程;





4. stop() 停止线程


(1) stop 方法停止线程的效果



stop 停止线程 : 

-- 1. 立即停止 : 调用 stop() 方法停止线程, 比较暴力, 会立即停止当前的线程;

-- 2. 抛出异常 : 使用 stop() 方法停止线程会抛出一个 ThreadDeath 异常, 这个异常可以不捕捉;

-- 3. 适用场景 : 适用该方法停止线程, 前提示 线程的相关数据 和 线程本身 都不再使用了, 否则会造成数据混乱;


stop() 停止线程效果演示 : 

-- 1. 代码示例 : 

public class StopDemo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			try {
				System.out.println("线程逻辑开始");
				super.run();
				for(int i = 0; i < 5000; i ++){
					System.out.println(i);
					sleep(100);	
				}
				System.out.println("线程逻辑结束");
			} catch (InterruptedException e) {
				System.out.println("捕获到了 InterruptedException 异常 , 进入了 catch 代码块");
				e.printStackTrace();
			}//catch代码块
			System.out.println("run 方法结束");
		}//run方法
	}//线程
	
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();	//新建线程
		thread.start();						//线程启动
		Thread.sleep(500); 					//沉睡 500ms, 让线程打印 5 个数字
		thread.stop();						//中断线程
		System.out.println("主线程中断线程");
	}
}


-- 2. 运行结果 : 

线程逻辑开始
0
1
2
3
4
主线程中断线程


-- 3. 总结分析 : 线程直接中断了, 线程中 run() 方法的最后一行代码也没有执行, 循环逻辑结束也没有执行, 说明线程很暴力的直接退出, 没有任何处理;




(2) stop 方法停止线程 捕获 ThreadDeath 异常




关于异常捕捉 : 

-- 1. 捕捉 ThreadDeath 异常 : 线程捕获异常处理后, 还会继续执行 try catch 代码块下面的代码;

-- 2. 不捕捉 ThreadDeath 异常 : 线程直接从 stop 时刻退出, 不会执行下面的代码;


stop() 停止线程 并 捕获异常 效果演示 : 

-- 1. 代码示例 : 代码中比上面多了一个 catch ThreadDeath 异常的代码块, 其它一样;

public class StopDemo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			try {
				System.out.println("线程逻辑开始");
				super.run();
				for(int i = 0; i < 5000; i ++){
					System.out.println(i);
					sleep(100);	
				}
				System.out.println("线程逻辑结束");
			} catch (InterruptedException e) {
				System.out.println("捕获到了 InterruptedException 异常 , 进入了 catch 代码块");
				e.printStackTrace();
			}catch (ThreadDeath e){
				System.out.println("捕获到了 ThreadDeath 异常 , 进入了 catch 代码块");
				e.printStackTrace();
			}//catch代码块
			System.out.println("run 方法结束");
		}//run方法
	}//线程
	
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();	//新建线程
		thread.start();						//线程启动
		Thread.sleep(500); 					//沉睡 500ms, 让线程打印 5 个数字
		thread.stop();						//中断线程
		System.out.println("主线程中断线程");
	}
}


-- 2. 运行结果 : 

线程逻辑开始
0
1
2
3
4
主线程中断线程
捕获到了 ThreadDeath 异常 , 进入了 catch 代码块
run 方法结束
java.lang.ThreadDeath
	at java.lang.Thread.stop(Unknown Source)
	at com.hanshuliang.thread.StopDemo.main(StopDemo.java:31)


-- 3. 总结分析 : 如果捕获了 ThreadDeath 异常, 就会处理这个异常, 并会执行异常处理后面的代码, run() 方法的最后一行代码也执行完毕了;




5. return 停止线程



return 停止线程说明 : 

-- 1. 执行过程 : 线程运行中, 随时监测中断标记, 如果检测到中断标记后, 直接 return 退出 run 方法;

-- 2. 不建议使用该方法, 多个 return 会污染代码;


return 退出演示 : 

-- 1. 代码示例 : 

public class ReturnDemo {
	public static class MyThread extends Thread{
		@Override
		public void run() {
			super.run();
			for(int i = 0; i < 500; i ++){
				if(interrupted()){				//判断线程的中断状态, 如果中断直接 break
					System.out.println("停止状态, return 退出");
					return;
				}
				System.out.println(i);
			}
			System.out.println("MyThread 线程执行完毕");//线程结束标志
		}
	}
	public static void main(String[] args) throws InterruptedException {
		MyThread thread = new MyThread();		//创建线程并执行
		thread.start();							//启动线程
		Thread.sleep(1);						//沉睡 1 毫秒
		thread.interrupt();						//中断线程
		System.out.println("主线程执行完毕");	//判断主线程停止
	}
}


-- 2. 执行结果 : 

... ...
35
36
37
38
39
主线程执行完毕
停止状态, return 退出


-- 3. 总结分析 : 使用 return 直接退出 run 方法, 确实实现了立即停止线程的目的, 但是我们还是建议使用 异常法 控制线程停止;



.



四. 线程暂停



线程停止常用方法 : 

-- 1. 使用 interrupt() 方法停止线程;

-- 2. 使用退出标志, 让线程正常退出;

-- 3. 弃用的方法 (不推荐) : 使用 stop() 方法强制停止线程, 但是该方法已经作废, 不建议使用;


1. 使用 interrupt() 方法停止线程


(1) 线程无法立即停止



interrupt() 使用说明 : 



.

























.





















.


















.



转载注明出处 : http://blog.csdn.net/shulianghan/article/details/52369486

韩曙亮
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程-Thread类的常用结构及线程优先级
01-27
Java多线程--Thread类的常用结构及线程优先级
JAVA有什么办法让定时停止,java通过接口开启和停止定时任务
weixin_39616416的博客
03-09 2834
1.思路说明(a)首先这里我们需要重新认识一个类ThreadPoolTaskScheduler：线程池任务调度类，能够开启线程池进行任务调度。(b)ThreadPoolTaskScheduler.schedule()方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable(线程接口类) 和CronTrigger(定时任务触发器)(c)在ScheduledF...
C++优雅地开启/暂停/停止线程——基于观察者模式
崔杰城的博客
12-05 2229
在编程中经常需要创建子线程来执行耗时的任务，避免主线程卡死，提高程序性能。其中有很多业务场景需要我们可以自由控制子线程的开启/暂停/终止。比如音视频播放器，除了用来操作ui控件的GUI主线程外，还有音视频数据解封装线程、视频解码线程、音频解码线程。用户按下“播发”按钮要能开始播放视频（开启所有子线程），用户按下“暂停”按钮要能暂停播放视频（暂停所有子线程”，用户按下“停止”按钮要能结束播放视频（终止所有子线程）。针对这种业务场景我们需要有个机制：当用户按下某个按钮后，GUI主线程可以通知所有的子线程开启/暂
interrupt()、interrupted()和isInterrupted()你真的懂了吗
weixin_47382783的博客
07-31 2412
前面提到interrupted()方法连续两次调用的返回结果不一样，因为第二次调用的时候线程的中断状态已经被清除，会返回一个false。也就是说，当前线程main并没有被中断过，即Thread.interrupted()方法其实相当于main.interrupted()，而Thread.interrupted()方法检测的是mt线程有没有被中断。上面都是针对当前线程进行操作，其运行结果也符合我们的预期true-true-false，因为interrupted()方法是有检测中断并清除中断状态的作用。....
线程中断标志位 interrupt()、interrupted()、isInterrupted() 的认识
龚小帅的博客
09-16 1422
首先一个线程不应该有其他线程来强制中断或者停止，而是线程自己停止，所以之前老版本的 stop()、suspend()、resume() 方法都已经过期了。其次在 Java 中没法立即停止一个线程，然后停止线程又是显得极为重要，那么又该如何取消一个耗时严重的线程呢？这里出现了一种协商机制——中断机制。中断机制。
线程基础概念
fakerth的博客
12-05 857
线程基础概念
java并发编程：线程基础
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程的创建和管理，以及线程间通信的基本方法。通过深入学习，您将建立扎实的多线程编程基础，能够更好地理解和应用多线程编程。 多...
Java 多线程的创建及方法、优先级.docx
最新发布
01-16
Java 多线程的创建及方法、优先级
Java多线程编程之限制优先级
01-20
限制线程优先级和调度 Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。...
Java 多线程优先级实例详解
08-30
主要介绍了Java 多线程优先级实例详解的相关资料,需要的朋友可以参考下
java并发编程--线程定义、创建、启动、停止
耗子扛刀满街找猫gg的博客
04-21 227
一、进程与线程的区别 1.进程是程序运行资源分配的最小单位，也就是说操作系统封是以进程为单位进行分配资源的，资源包括cpu时间片、内存、磁盘io等；进程与进程之间是相互独立的，一个应用程序可以理解为一个进程，当你打开微信又打开支付宝的时候这两个应用都可以正常工作，所以说进程之间的独立的。进程又可以分为系统进程和用户进程，比如当你按下电脑卡机键，你就可以打开桌面，这是系统启动的进程；而你打开浏览器，...
线程暂停和唤醒的多种方式
dream_xin2013的专栏
03-24 1603
线程通信个人理解为当一个线程A执行到某个特定条件时，通知其他线程继续执行
C++多线程编程——线程的挂起、唤醒与终止
热门推荐
张人杰的博客
02-05 1万+
C++多线程编程——线程的挂起、唤醒与终止 (2010-10-11 10:09:04) 转载▼ 标签： 杂谈 分类：Win32 在线程创建并运行后,用户可以对线程执行挂起和终止操作.所谓挂起,是指暂停线程的执行,用户可以通过气候的唤醒操作来恢复线程的执行.线程终止是指结束线程的运行.系统提供了SuspendThread,ResumeThrea
在用户级实现多线程调度，如启动、挂起、恢复、停止
weixin_42678674的博客
11-05 848
理解多线程，写一个多线程应用程序，要求能在用户级实现线程的调度，如启动、挂起、恢复、停止。 1.进程与线程 进程：进程是资源分配的最小单位，有独立的代码和数据空间，1个进程包含1~N个线程。 线程：线程是CPU调度的最小单位，同一类线程共享代码和数据空间，1条线程指的是进程中一个单一顺序的控制流。 2.多进程与多线程 多进程：操作系统同时运行多个任务（程序）。 多线程：在同一个程序中有多个顺序流在...
控制多线程，开启、暂停、继续、终止（实例）
weixin_30907935的博客
02-08 1565
我们这些文盲以前一听到多线程这么几个字，以为非常的高级，难搞！！昨天翻阅了一下MSDN，发现，其实也没那么难，关键在于全面的理解，也许是用多了API了，慢慢的会看懂了一些！！！ 我总结了几个易于理解的出来，一起共享！ 我们先不讲如何使用线程过程中的参数；先来个简单的；下篇文章我们在讲如何使用线程...
Linux/C/C++ 条件变量实现线程的暂停、继续、停止功能
weixin_45646368的博客
03-10 2003
1.threadControl.cpp #include <iostream> #include <mutex> #include <vector> #include <thread> #include <chrono> #include <condition_variable> enum THREAD_CONTROL { THREAD_RUN, THREAD_PAUSE, THREAD_STOP,
QThread如何优雅实现暂停(挂起)功能
百里杨的博客
05-23 1万+
一、实现思路 QThread中有start、quit，但是没有pause，那么我们想要实现这个功能。 我们继承QThread，重写run()； 第一反应是不是应该添加个标志，在run()中判断暂停状态。嗯，没错，不过我们不能用普通变量，否则有线程非安全风险。这里使用C++提供的原子类型std::atomic_bool。 线程暂停期间，不能空跑消耗cpu，故我们使用Qt条件变量QWaitCondition，配合QMutex。 大概就是这么点内容吧，实现代码如下： Thread.h #include &lt
GVM升级后启动异常处理
一杯咖啡的渗透记忆
08-05 8394
1. Kali升级 apt-get update apt-get dist-upgrade 2. 升级完成后，启动GVM（OpenVas）发现打不开： oot@Fkali:~# gvm-start [*] Please wait for the GVM / OpenVAS services to start. [*] [*] You might need to refresh your browser once it opens. [*] [*] Web UI (Greenbone Secur..
【并发基础】一篇文章带你彻底搞懂Java线程中断的底层原理——interrupt()、interrupted()、isInterrupted()
小七的博客
04-23 3580
一篇文章带你彻底搞懂Java中断机制，从底层源码带你分析interrupt()的机制与用法。学习Java中断看这一篇就够了。
java多线程中获取优先级方法
05-24
Java中获取线程优先级的方法是使用Thread类的getPriority()方法。该方法返回一个整数值，表示线程的优先级，其范围从1到10，其中1是最低优先级，10是最高优先级。例如： ``` Thread t = new Thread(); int priority = t.getPriority(); System.out.println("线程的优先级为：" + priority); ``` 如果需要设置线程的优先级，则可以使用Thread类的setPriority(int priority)方法。例如： ``` Thread t = new Thread(); t.setPriority(8); ``` 以上代码将线程t的优先级设置为8。需要注意的是，线程的优先级只是给操作系统一个提示，操作系统不一定会按照优先级来调度线程。因此，不能过度依赖线程的优先级来控制程序的行为。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值