（六）多线程说学逗唱：线程的暂停与其优先级

最新推荐文章于 2024-01-11 11:33:35 发布
最新推荐文章于 2024-01-11 11:33:35 发布
阅读量385 收藏
点赞数 2
分类专栏： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WJHelloWorld/article/details/84992722
版权
  • 接着上一篇文章讲，在这一篇的篇幅中我将继续带着大家学习java多线程中的一些常用方法。接下来会讲到如何让线程暂停和重启、放弃资源以及线程优先级的相关问题。
suspend()方法和resume()
  • 在java多线程中，也会遇到线程的暂停这种情况，实现这一需求就是使用suspend()方法让线程暂停，resume（）方法则是让线程重新启动。我们来看下面的例子，suspendAndResumeThread线程暂停后两秒再启动。
package day04;
/**
 * 
* @ClassName: SuspendAndResumeTest
* @Description: 线程暂停与重启测试学习
* @author Jian.Wang
* @date 2018年12月11日
*
* 
 */
public class SuspendAndResumeTest {
	private static final String MY_THREAD_NAME = "王守田";
	
	@SuppressWarnings("deprecation")
	public static void main(String[] args) {
		try {
			SuspendAndResumeThread suspendAndResumeThread = new SuspendAndResumeThread(MY_THREAD_NAME);
			System.out.println("suspendAndResumeThread线程名称为： " + suspendAndResumeThread.getName() + "--" + suspendAndResumeThread.getId() );
			suspendAndResumeThread.start();
			System.out.println("线程暂停了.........." + System.currentTimeMillis());
			suspendAndResumeThread.suspend();
			Thread.sleep(2000);
			suspendAndResumeThread.resume();
			System.out.println("线程启动了.........." + System.currentTimeMillis());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


/**
 * 
* @ClassName: SuspendAndResumeThread
* @Description: 线程暂停与重启
* @author Jian.Wang
* @date 2018年12月11日
*
 */
class SuspendAndResumeThread extends Thread{
	public SuspendAndResumeThread() {
	}
	public SuspendAndResumeThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("线程中输出的数据： " + i);	
		}
	}
}

在这里插入图片描述

  • 在代码中细心的同学可能已经注意到了，suspend() 方法和resume() 方法是这样的，过时了！！是的，因为这两个方法在使用的时候会出现一些问题，第一个问题就是：独占，也就是说如果使用不当的话可能造成公共的同步对象的独占，使得其他线程无法访问公共的同步对象。看下面的例子：
package day04;

import java.util.Objects;

/**
 * 
* @ClassName: MonopolyTest
* @Description: suspend()方法和resume()方法存在缺点一 -- 独占。
* @author Jian.Wang
* @date 2018年12月11日
*
 */
public class MonopolyTest {
	private static final String THREAD_FIRST_NAME = "王守田";
	private static final String THREAD_SECCEND_NAME = "王守地";
	
	public static void main(String[] args) {
		try {
			MonopolyThreadBasic monopolyThreadBasic = new MonopolyThreadBasic();
			Thread threadFirst = new Thread(monopolyThreadBasic,THREAD_FIRST_NAME);
			Thread threadSeccend = new Thread(monopolyThreadBasic,THREAD_SECCEND_NAME);
			System.out.println("当前时间戳---" + System.currentTimeMillis());
			threadFirst.start();
			Thread.sleep(2000);
			threadSeccend.start();
			System.out.println("当前时间戳---" + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}


/**
 * 
* @ClassName: MonopolyThreadBasic
* @Description: 基础线程类
* @author Jian.Wang
* @date 2018年12月11日
*
 */
class MonopolyThreadBasic extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + " -- " + Thread.currentThread().getId() + "访问了线程.......");
		SynchronizedObject.printString();
	}
}

/**
 * 
* @ClassName: SynchronizedObject
* @Description: 同步类，包含同步方法，模拟线程堵塞
* @author Jian.Wang
* @date 2018年12月11日
*
 */
class SynchronizedObject{
	private static final String MY_THREAD_NAME = "王守田";
	@SuppressWarnings("deprecation")
	synchronized public static void printString() {
		System.out.println("进入到了printString方法中.......");
		if (Objects.equals(Thread.currentThread().getName(), MY_THREAD_NAME)) {
			System.out.println(Thread.currentThread().getName() + "线程怕是要永远停止了哟........");
			Thread.currentThread().suspend();
		}
		System.out.println("马上要出printString方法了.......");
	}
}

在这里插入图片描述

  • 根据输出我们可以看到，当名为王守田的线程执行同步方法中的代码时候进行了暂停，此时王守田一直霸占着公共资源不释放，此时名为王守地的线程进入，但是只能进入到run方法中执行第一行代码，无法进入到同步方法printString（）方法中，此时程序一直一直在等待（右上角的红色方块就代表程序并未终止…），此时王守田出不去，王守地进不来，很尴尬。这就说明在使用暂停方法的时候很容易出现线程独占的巨大问题。
  • 不同步，也是使用suspend()方法和resume()方法时很容易就会遇到的问题。当某一个线程在修改某一数据之后并没有完全修改完成就将线程暂停了，此时另外一个线程刚好获取到了这个修改了一半的值，此时数据就不同步了，我们来看下面的例子，输出结果：王守田 : wangshoudi就对不上。
package day04;
import java.util.Objects;
/**
 * 
* @ClassName: NoSynchronizationCharacter
* @Description: suspend()方法和resume()方法存在缺点二 -- 不同步。
* @author Jian.Wang
* @date 2018年12月11日
*
 */
public class NoSynchronizationCharacter {
	private static final String MY_THREAD_NAME = "王守田";
	private static final String MY_THREAD_PASSWORD = "wangshoutian";
	private static final String HE_THREAD_NAME = "王守林";
	public static void main(String[] args) {
		try {
			BasicObject basicObject = new BasicObject();
			new Thread(MY_THREAD_NAME) {
				@Override
				public void run() {
					basicObject.setValue(MY_THREAD_NAME, MY_THREAD_PASSWORD);
				}
			}.start();
			Thread.sleep(1000);
			new Thread(HE_THREAD_NAME) {
				@Override
				public void run() {
					basicObject.printUserNameAndPassword();
				}
			}.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

/**
 * 
* @ClassName: BasicObject
* @Description: 基础方法类
* @author Jian.Wang
* @date 2018年12月11日
*
 */
class BasicObject {
	private final static String MY_THREAD_NAME = "王守田"; 
	private String userName = "王守地";
	private String password = "wangshoudi";
	
	@SuppressWarnings("deprecation")
	public  void setValue(String u, String p) {
		this.userName  = u;
		if (Objects.equals(Thread.currentThread().getName(), MY_THREAD_NAME)) {
			System.out.println("线程" + Thread.currentThread().getName() + "将要停止......");
			Thread.currentThread().suspend();
		}
		this.password = p;
	}
	public void printUserNameAndPassword() {
		System.out.println(userName + " : " + password);
	}
}

在这里插入图片描述

yieId()方法 放弃运行资格
  • yieId（）方法的作用是放弃当前的CPU资源，将它给其他的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚刚放弃，又马上获得CPU时间片。CPU时间片可能有些同学不是很理解，时间片的概念在计算机操作系统中是一个比较重要的概念，它是分时操作系统分配给每个正在运行的进程微观上的一段CPU时间，在计算机中，并不是所有的程序都是一个并行的执行过程，而是某一个时间片内执行某一个进程或者进程中的某一个线程，因为CPU的执行速度十分快，快到我们完全无法感觉到，以至于认为所有的东西都是同时发生的。当某一个线程获取到了CPU的执行权的时候，使用yieId（）方法放弃执行资格，也就是我们平时说的：现在我们把时间交给谁谁谁。现在我们来看例子：
package day04;

import java.util.Objects;

/**
 * 
* @ClassName: YieIdTest
* @Description: 放弃运行资格校验
* @author Jian.Wang
* @date 2018年12月11日
*
 */
public class YieIdTest {
	private static final String MY_FIRST_THREAD_NAME = "王守田";
	private static final String MY_SECCEND_THREAD_NAME = "王守地";
	public static void main(String[] args) {
		try {
			YieTestThread firstThread = new YieTestThread(MY_FIRST_THREAD_NAME);
			YieTestThread seccendThread = new YieTestThread(MY_SECCEND_THREAD_NAME);
			firstThread.start();
			seccendThread.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

/**
 * 
* @ClassName: YieTestThread
* @Description: 线程类
* @author Jian.Wang
* @date 2018年12月11日
*
 */
class YieTestThread extends Thread{
	private static final String MY_THREAD_NAME = "王守田";
	public YieTestThread() {
	}
	public YieTestThread(String name) {
		super(name);
	}
	@SuppressWarnings("static-access")
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " : " + i);
			if (Objects.equals(Thread.currentThread().getName(), MY_THREAD_NAME) && Objects.equals(50, i)) {
				System.out.println("我要放弃CPU资源了...................");
				Thread.currentThread().yield();
			}
		}
	}
}

在这里插入图片描述

  • 上面结果可以看到，王守田先拿到了线程执行资格，但是在代码中设置了输出到50就让出执行资格给王守地，上面的例子就很好地说明了yieId（）方法的使用和作用了。
线程优先级
  • **在Thread中，定义了三个值用来设置线程执行的优先级MIN_PRIORITY = 1、NORM_PRIORITY = 5以及MAX_PRIORITY = 10。默认的值为NORM_PRIORITY 。**在多数的多线程程序中一般都是使用默认的线程优先级，手动设置的话可能会赵成不必要的问题。
  • 线程优先级具有三个特点：
  • 继承性：比如A线程类的优先级为10，那么他的被继承类的优先级同样为10.
  • 规则性：高优先级的线程会先执行，但是不代表高优先级的线程会一直一直执行下去，直到其执行完成，在有些时候高优先级在执行的时候也会让出时间片给优先级低的线程执行。
  • 随机性：线程执行随机，不看代码先后。
勤勤恳恳王守田
关注
专栏目录
多线程之线程暂停
qq_27581753的博客
04-29 1405
暂停线程意味着此线程还可以恢复运行。在Java多线程中，可以使用suspend()方法暂停线程，使用resume()方法恢复线程执行。 1.suspend与resume方法的使用 这边我将通过示例 来讲述： package test; /** * @Author LiBinquan */ public class ThreadTest extends Thread{ private ...
Java多线程详解
weixin_44530708的博客
02-10 1323
java多线程问题分析与共享
【Java多线程】——暂停线程与线程优先级
名侦探张六儿的博客
05-04 233
1、暂停线程暂停线程意味着此线程还可以恢复运行，java中用suspend()暂停线程，用resume()恢复线程的运行。suspend与resume有一个共同的缺点——独占。在使用这两个方法的时候，如果使用不当，极易造成对公共的同步对象的独占，使得其他线程无法访问公共的同步对象。比如一个线程调用了一个同步方法或者是操作了一个同步代码块指定的同步对象，而在同步方法调用完毕之前调用了suspend(...
[多线程] 停止和暂停线程以及线程的优先级，同步锁
weixin_30448685的博客
03-20 107
停止线程 停止线程是在多线程开发时很重要的技术点，掌握此技术可以对线程的停止进行有效的处理。 停止一个线程可以使用Thread.stop()方法，但最好不用它。该方法是不安全的，已被弃用。 在Java中有以下3种方法可以终止正在运行的线程： 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止 使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspen...
Java中线程优先级、线程的状态以及启动和终止线程
...
06-18 296
线程概念：现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程中可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换。 线程优先级 现代操作系统基本采用时分的形式调度运行的线程。线程分配到的时间片多少也就决定了使用处理器资源多少，而线程优先级就是决定线程需要多或少分配一些处理器资源的线程属性。 在Java线程中，通过一个整型成员变量priority来控制优先级，优先级范围从1~10，在线
线程暂停、睡眠、让步、优先级设置、守护线程
xingze的博客
08-04 284
文章目录线程控制暂停线程：join后台线程线程睡眠：sleep线程让步：yieldsleep()和yield()的区别改变线程优先级 线程控制         当同一时刻有多个线程处于可运行状态，它们需要排队等待CPU资源，每个线程会自动获得一个线程的优先级（Priority），优先级的高低反映线程的重要或紧急程度。可...
java 多线程&getStackTrace()方法——15
爱的叹息的专栏
06-06 631
getStackTrace()方法的作用是返回一个表示该线程 堆栈跟踪元素数组。如果该线程尚未启动或已经终止，则该方法将返回一 个零长度数组。如果返回的数组不是零长度的，则其第一个元素代表堆栈 顶，它是该数组中最新的方法调用。最后一个元素代表堆栈底，是该数组 中最旧的方法调用。...
多线程运行机制概要[文].pdf
10-12
当一个阻塞的线程恢复为可运行状态时，它会被放回与其优先级相对应的线程池中。然后，CPU时间会分配给最高优先级且非空的线程池中的线程。 线程的优先级是决定哪个线程应该获得执行权的重要因素。Java提供了一个...
Java多线程编程实战指南-核心篇
hanzong110的博客
07-01 1016
1 多线程编程基础 1.1 进程与程序 进程是程序的运行实例，类似播放中的视频和视频文件的关系 1.2 创建线程的两种方式 继承Thread重写run方法 提供Thread对象一个Runnable对象 1.3 Thread与Rnnable的关系 Thread是对线程的抽象，Runnable是对线程要执行的任务的抽象 1.4 线程的属性 ID：不适合用作某种唯一标识 Name：有助于代码调试和问题定位 Daemon true表示守护线程，false表示用户线程 main方法由用户线程执行 Java虚拟
【Java】最全Java多线程面试指北
Slimshady的博客
06-26 1465
文章目录Java多线程基础知识并发编程的优缺点并发编程三要素出现线程安全问题的原因怎么保证多线程的运行安全并行和并发多线程的优缺点线程和进程进程线程进程与线程的区别上下文切换守护线程和用户线程如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？创建线程的四种方式继承 Thread 类实现 Runnable 接口实现 Callable 接口使用 Executors 创建线程池Runnable 和 Callable 区别run()和 start()区别Callable 和 Future?Fu
Java并发多线程基础总结
u012497653的博客
11-26 726
Java深入学习并发原理总结 线程核心一：实现多线程的正确姿势 实现多线程到底有几种 网上有说 2 种，3 种，4 种，6 种等等 ????‍♂️ 我们看 Oracle 官网 API 是怎么描述的。 官方描述为两种： 继承 Thread 类 实现 Runnable 接口 有两种方法可以创建新的执行线程。 一种是将一个类声明为 Thread 的子类。 该子类应重写 Thread 类的 run 方法。 然后可以分配并启动子类的实例。 public class ThreadTest extend
三.线程停止、中断
as513385的博客
04-08 879
三线程停止、中断之最佳实践 1.停止线程的正确方法(原理) 通常线程会在什么情况下停止 正常运行的线程只有在两种状况下会停止 1.run方法的代码全部执行完毕,正确结束的情况 2.出现异常,并且方法没有捕获,这时线程也会停止 线程停止之后,它所占有的资源比如说内存等,都会和其他不可达的对象一样被jvm回收 通过interrupt来通知,而不是强制停止 注意只是通知,如果被通知线程执行的代码没有对这个通知进行处理,没有在被捕获的异常中做相应的退出操作,那么是不会真正退出的,而是直接执行到run方法代码结束为止
Java线程中断攻略: 详解Java线程中断及线程中断的几种使用场景
最新发布
wcwmsj的博客
01-11 3342
在多线程编程中，线程中断技术是确保程序健壮性和可靠性的不可或缺的一部分。本文将深入探讨Java中的线程中断技术，以通俗易懂的方式介绍其概念、机制以及在实际项目中的应用。
Thread.currentThread().getStackTrace()[?]
qq_37361360的博客
10-26 1839
原文地址：点击跳转 测试代码： public static void main(String[] args) { getName4(); } public static void getName1() { String methodName0 = Thread.currentThread().getStackTrace()[0].getMethodName(); String methodName1 = Thread.curren.
Thread 实现 方法访问来源跟踪
kangojian的专栏
01-04 1065
StackTraceElement[] el = Thread.currentThread().getStackTrace();      Map map = Thread.getAllStackTraces();     System.out.println(map.size()+"^^^^^^^^^^^^^^");     for(StackTraceElement[] el2: ma
Java通过Thread.currentThread().getStackTrace()[1].getClassName()；获得当前类名速度性能测试
kfepiza的博客
06-02 780
Java通过Thread.currentThread().getStackTrace()[1].getClassName();获得当前类名速度性能测试
ThreadLocal学习笔记
m0_62811136的博客
10-12 613
但是，也要值得注意的是，现在很多线程创建都是线程池的模式，也就是说可能线程创建出来后，会被一直重复使用，不会短时间内死去（所以ThreadLocalMap指向的对象也不会gc），这时需要注意若是 ThreadLocal 对象的强引用是否有置为null的操作，或者说创建 ThreadLocal的线程死掉了。1、一般ThreadLocal创建出来时，一般都是强引用，而且是共享资源，这时ThreadLocalMap里面的key是不会有gc的场景的，除非创建ThreadLocal这个线程也没了。
线程（小结）
m18846420582的博客
10-18 188
线程安全的几个类 函数： isAlive（）：判断当前线程是否存活。 Thread.sleep是将主线程停止1秒，而不是将mythread线程停止1秒 线程安全(Thread-safe)的集合对象： Vector 线程安全： HashTable 线程安全： StringBuffer 线程安全 实现多线程的方法：继承Thread类，实现Runnable 接口。 start 方法异步执行，让系统安排一个时间来调用Thread.run方法 run方法同步执行，由main的主线程调用run方法。（因此RU.
学习：Objects.equal方法
czp_374的博客
09-03 937
https://blog.csdn.net/llllllllll4er5ty/article/details/80328078
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值