线程总结(sleep,join,yield,getPriority,setPriority,wait,notify,notifyAll)

最新推荐文章于 2021-05-29 03:12:43 发布
原创 最新推荐文章于 2021-05-29 03:12:43 发布 · 145 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#thread #编程

1.sleep

    是Thread的静态方法，public static void sleep(long mililis) throws InterruptedException 使得当前线程处于休眠状态。Tread.sleep();

sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间片，指定的时间一过，线程重新进入可执行状态。说白了 ，也就是把机会给其他线程，但是监控状态依然保持。重要的一点就是 当调用sleep（）方法是 不会 释放对象锁的。

     举例：

  

public class SleepTest implements Runnable {
	static int b = 100;
	
	public void run() {
		try {
			System.out.println("m1");
			b--;
			Thread.sleep(5000);
			System.out.println("m1" + "Thread=" + Thread.currentThread().getName()
					+ " " + this + " " + "b=:" + b);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String args[]) throws Exception {
		SleepTest ss = new SleepTest();
		Thread tt = new Thread(ss);
		Thread tt1 = new Thread(ss);
		tt.start();
		tt1.start();
	}
}

  

   运行结果：

    m1
    m1
    m1Thread=Thread-0 CopyOfsynchro@f62373 b=:98
    m1Thread=Thread-1 CopyOfsynchro@f62373 b=:98

 

2.wait,notify,notifyall

    是Object 类的方法。所有对象都拥有这一对方法。这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。

notify（）是释放对象的wait（）方法而阻塞线程（但是也要当得到锁后才可以运行）但是这个释放是随机的，也就是不一定要释放那个线程。（因为调用同一资源的可能不是一个线程或者说是有多个阻塞的线程在等待，但是如果加了synchronized也只有一个线程，也有其他的线程在等待中，也就是阻塞）我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。
　　同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现 IllegalMonitorStateException 异常。

 举例：生产者与消费者

public class ProducerConsumer {
	public static void main(String args[]){
		SyncStack ss = new SyncStack();
		Producer p = new Producer(ss);
		Consumer c = new Consumer(ss);
		new Thread(p).start();
		new Thread(c).start();
	}
}
class WoTou{
	int id ;
	public WoTou(int id){
		this.id = id;
	}
	public String toString(){
		return "WoTou:"+id;
	}
}
class SyncStack{
	int index = 0;
	WoTou[] awtWT = new WoTou[6];
	
	public synchronized void push(WoTou wt){
		while(index == awtWT.length){
			try {
				this.wait();//当前的正在访问对象的线程wait
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();
		awtWT[index] = wt;
		index ++; 
	}
	
	public synchronized WoTou pop(){
		while(index == 0){//if->while：如果catch住异常后，假如是if并且index=0，index == 0 不再判断，index--会执行， 程序错误。所以改为while,可以避免发生如此错误。
			try {
				this.wait();//当前的正在访问对象的线程阻塞（wait）,wait后对象的锁不归线程所有，直到"醒了"（notify,notifyALL），再重新找回锁。
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();//叫醒一个正在当前对象上wait的线程。
		index--;
		return awtWT[index];
	}
}

class Producer implements Runnable{
	SyncStack ss = null;
	Producer(SyncStack ss){
		this.ss = ss;
	}
	public void run() {
		for(int i=0;i<20;i++){
			WoTou wt = new WoTou(i);
			ss.push(wt);
			System.out.println("Producer："+wt);
			try {
				Thread.sleep((int)(Math.random()*100));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}	
	}
}
class Consumer implements Runnable{
	SyncStack ss = null;
	Consumer(SyncStack ss){
		this.ss = ss;
	}
	public void run() {
		for(int i=0;i<20;i++){
			WoTou wt = ss.pop();
			System.out.println("Consumer："+wt);
			try {
				Thread.sleep((int)(Math.random()*1000));//目的是让其他线程有执行的机会。
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}	
	}
}

执行结果： 

Producer：WoTou:0
Consumer：WoTou:0
Producer：WoTou:1
Producer：WoTou:2
Producer：WoTou:3
Producer：WoTou:4
Producer：WoTou:5
Producer：WoTou:6
Consumer：WoTou:6
Producer：WoTou:7
Producer：WoTou:8
Consumer：WoTou:7
Producer：WoTou:9
Consumer：WoTou:8
Consumer：WoTou:9
Producer：WoTou:10
Consumer：WoTou:10
Producer：WoTou:11
Consumer：WoTou:11
Producer：WoTou:12
Consumer：WoTou:12
Producer：WoTou:13
Consumer：WoTou:13
Producer：WoTou:14
Consumer：WoTou:14
Producer：WoTou:15
Consumer：WoTou:15
Producer：WoTou:16
Consumer：WoTou:16
Producer：WoTou:17
Consumer：WoTou:17
Producer：WoTou:18
Consumer：WoTou:18
Producer：WoTou:19
Consumer：WoTou:19
Consumer：WoTou:5
Consumer：WoTou:4
Consumer：WoTou:3
Consumer：WoTou:2
Consumer：WoTou:1

3.join

   合并某个线程。（相当方法调用）

   举例：   

public class TestJoin implements Runnable {
	static int b = 100;
	
	public void run() {
		try {
			System.out.println("m1");
			b--;
			System.out.println("m1" + "Thread=" + Thread.currentThread().getName()
					+ " " + this + " " + "b=:" + b);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String args[]) throws Exception {
		TestJoin ss = new TestJoin();
		Thread tt = new Thread(ss);
		Thread tt1 = new Thread(ss);
		tt.start();
		tt.join(); //合并线程
		tt1.start();
	}
}

  

 运行结果：

   m1
   m1Thread=Thread-0 TestJoin@12b6651 b=:99
   m1
   m1Thread=Thread-1 TestJoin@12b6651 b=:98

  

4.yield

   让出ＣＰＵ给其他线程执行的机会。

   举例：

public class TestYield extends Thread {
	public void run() {
		try {
			for (int i = 0; i < 100; i++) {
				System.out.println(Thread.currentThread().getName() +"i=:" + i);
				if(i%10==0){
					yield(); //让出线程执行
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String args[]) throws Exception {
		Thread tt = new TestYield();
		Thread tt1 = new TestYield();
		tt.start();
		tt1.start();
	}
}

 

 

5.getPriority,setPriority

   Java 提供一个线程调度器来监控程序中启动后就进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。

   线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。

           Thread.MIN_PRIORITY = 1

           Thread.MAX_PRIORITY=10

           Thread.NORM_PRIORITY = 5

  使用下述方法获得或设置线程对象的优先级。

          int getPriority();

          void setPriority(int nexPriority);

举例：

public class TestPriority extends Thread{

	public void run() {
		try {
			for(int i=0;i<10;i++){
				System.out.println("m1" + "Thread="
						+ Thread.currentThread().getName() + " " + this + " "
						+ "i=:" + i);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String args[]) throws Exception {
		Thread ss = new TestPriority();
		Thread tt = new TestPriority();
		ss.start();
		tt.start();
		tt.setPriority(Thread.NORM_PRIORITY + 4);
	}
}

 一种运行结果：

m1Thread=Thread-0 Thread[Thread-0,5,main] i=:0
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:0
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:1
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:2
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:3
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:4
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:5
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:6
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:7
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:8
m1Thread=Thread-1 Thread[Thread-1,9,main] i=:9
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:1
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:2
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:3
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:4
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:5
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:6
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:7
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:8
m1Thread=Thread-0 Thread[Thread-0,5,main] i=:9

优先级高的运行时间长。
 

Java 并发编程：Java 线程模型介绍及使用
栗筝i的博客
08-01 793
Java 线程是指程序中可以独立执行的单个代码执行路径。Java 使用类和包来实现多线程编程。线程是并发编程的基础，可以提高应用程序的性能，特别是在处理 I/O 密集型或 CPU 密集型任务时。线程（Thread）：是一个独立的执行单元，可以与其他线程并发执行；进程（Process）：是一个正在执行的程序，每个进程至少包含一个线程（主线程）；多线程（Multithreading）：在同一进程内同时运行多个线程，以实现并发处理。
Thread类中join()、sleep()和、yield()方法详解
学而不思则忘
03-04 725
join()方法简介 wait()、notify()/notifyAll()是Object类中的方法，join()方法是Thread类直接提供的。 作用：在当前线程A中调用另外一个线程B的join()方法后，会让当前线程A阻塞，直到线程B的逻辑执行完成，A线程才会解阻塞，然后继续执行自己的业务逻辑。 join()原理分析 join()有三个重载的方法，通过Object类中的wait()、notify()/notifyAll()方法实现的。 public final synchronized void joi
Thread中sleep，wait，yield，setPriority学习心得
ahy231的博客
10-02 2486
Thread中sleep，wait，yield学习心得 Thread中控制线程暂停的三种重要方法就是sleep，wait和yield。对于三种方法的特点和用法，我在这里做了总结。 sleep() Thread.sleep()是暂停线程的常用方法，该方法必须指定暂停时长，并在暂停结束后自动醒来。当然，在sleep的过程中，也有方法直接唤醒线程，具体请问度娘。sleep函数的参数可以是(毫秒)或者(毫秒，纳秒)。 wait() wait方法本属于object类。要使用wait方法，当前对象必须拥有即锁(moni
android wait notify用法,Android 当中的多线程之 wait、sleep、notify、join、yield
weixin_33741534的博客
05-29 939
Android 当中的多线程实际上就是 Java SE 中的多线程，只是为了方便使用，Android 封装了一些类，比如 AsyncTask, HandlerThread等。今天我们总结一下 Android 当中的多线程基础知识。对于 Android 多线程，我们最早学习到的都是 Thread 和 Runnable ，通常我们使用如下代码来开启一个新的线程： public void sta...
多线程常用方法sleep(),wait(),join(),yield()总结.
qq_41582642的博客
03-14 673
sleep()和wait()的区别:--sleep锁还在/wait锁释放 sleep的方法主要是让线程暂时休息一段时间,时间一到自动恢复,因此,调用sleep方法不会释放锁. wait方法被调用,会释放锁. 简单来说wait()会释放对象锁而sleep()不会释放对象锁。 1.sleep();--让调用这个方法的正在执行的线程休眠一段时间--不释放锁 Thread.sleep(3000)//毫秒...
sleep()、yield()、join()、wait()/notify()、interupt()——多线程中常用的方法
weixin_41445507的博客
07-31 440
一、sleep()——线程休眠 线程休眠：指的是让线程暂缓执行一下，等到了预计时间之后再恢复执行。 线程休眠会交出CPU，让CPU去执行其他的任务。sleep() 方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep() 方法，其他线程也无法访问这个对象。 使程序从：运行态——>阻塞态 class MyThread implements Runnable{ ...
join、yield、wait、sleep方法区别理解
CodingMayCry
02-13 1208
参考各路网站及博客理解总结而来，如侵必删。 join()     一直不能理解Java多线程里面的join()方法到底是干什么的，有什么用。API给出的解释是： Waits for this thread to die.但是好像join和die没有什么关系啊，为何要用join呢？     子线程join到主线程（启动程序的线程，比如c语言执行main函数的线程）。你的问题可能在于没有理解jo...
Java并发07:Thread的基本方法(4)-Thread.sleep()、Object.wait()、notify()和notifyAll()
韩超的博客 (hanchao5272)
03-12 1515
[超级链接：Java并发学习系列-绪论] 本章主要对Java中Thread类的基本方法进行学习。 1.序言 Thread类作为线程的基类，提供了一系列方法，主要有： Thread.sleep(long)：强制线程睡眠一段时间。 Thread.activeCount()：获取当前程序中存活的线程数。 thread.start()：启动一个线程。 Thread.currentThread()...
Android中的线程之线程基础（synchronized，wait，sleep，yield，notify ）
小薇子的博客
06-24 1434
多线程基础 之synchronized，wait，sleep，yield，notify Android中的多线程实际上就是jAVA SE中的多线程，只是为了方便使用，Android封装了一些类，AsyncTask，HandlerThread等等。 首先，我们先看看Thread和Runnable； Thread和Runnable 通常我们使用如下的代码启动一个线程： pri...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 43万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
JAVA多线程编程详解与实例操作总结
setPriority(int priority)和getPriority()分别用于设置和获取线程的优先级，取值范围为1到10，其中1为最低优先级（MIN_PRIORITY），5为默认优先级（NORM_PRIORITY），10为最高优先级（MAX_PRIORITY）。需要注意的是...
Java多线程总结.pdf
09-30
在Java中，线程的优先级可通过`setPriority(int newPriority)`方法设置，并通过`getPriority()`获取，优先级分为`MIN_PRIORITY`（最低优先级值为1），`NORM_PRIORITY`（默认优先级值为5），和`MAX_PRIORITY`（最高...
Java多线程基础练习题解析：线程创建、死锁与状态控制
在线程优先级管理方面，文档提及了`setPriority(int newPriority)`方法。每个线程都有一个优先级，默认继承自创建它的父线程，取值范围为1到10，其中`Thread.MIN_PRIORITY=1`，`Thread.MAX_PRIORITY=10`，`Thread....
基于SSM与Vue架构的病人跟踪治疗信息管理系统设计与实现（含源码及文档）
12-22
基于SSM架构与Vue技术构建的病人治疗追踪管理系统，采用Java编程语言实现业务逻辑，并以MySQL数据库作为数据存储支持。该系统主要包含三个用户角色：管理员、病人及普通访客。 管理员具备的功能模块包括：主界面、个人设置、病人档案管理、病例信息采集、预约安排、医生信息维护、核酸检测报告上传管理、行动轨迹记录管理、疾病分类配置、病人治疗进度跟踪、留言板处理以及系统参数管理。病人用户可操作：主界面、个人设置、病例信息查看、预约申请、医生查询、核酸检测报告上传、行动轨迹上报、个人治疗状态查询。访客端提供：首页浏览、医生信息展示、医疗资讯发布、留言反馈提交、个人中心、后台入口及在线咨询服务。 系统设计注重代码结构的清晰性与可维护性，强调功能实用性和界面简洁度，同时保持较强的扩展适应能力，便于后续功能升级与日常运维。 项目已通过实际运行测试，开发环境配置如下： - 编程语言：Java - 开发框架：Spring Boot - Java开发工具包：JDK 1.8 - 应用服务器：Tomcat 7 - 数据库系统：MySQL 5.7 - 数据库管理工具：Navicat 12 - 集成开发环境：Eclipse或IntelliJ IDEA - 项目构建工具：Maven 3.3.9。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
电力系统单机无穷大电力系统短路故障暂态稳定Simulink仿真（带说明文档）
最新发布
12-22
【电力系统】单机无穷大电力系统短路故障暂态稳定Simulink仿真（带说明文档）内容概要：本文档围绕“单机无穷大电力系统短路故障暂态稳定Simulink仿真”展开，提供了完整的仿真模型与说明文档，重点研究电力系统在发生短路故障后的暂态稳定性问题。通过Simulink搭建单机无穷大系统模型，模拟不同类型的短路故障（如三相短路），分析系统在故障期间及切除后的动态响应，包括发电机转子角度、转速、电压和功率等关键参数的变化，进而评估系统的暂态稳定能力。该仿真有助于理解电力系统稳定性机理，掌握暂态过程分析方法。; 适合人群：电气工程及相关专业的本科生、研究生，以及从事电力系统分析、运行与控制工作的科研人员和工程师。; 使用场景及目标：①学习电力系统暂态稳定的基本概念与分析方法；②掌握利用Simulink进行电力系统建模与仿真的技能；③研究短路故障对系统稳定性的影响及提高稳定性的措施（如故障清除时间优化）；④辅助课程设计、毕业设计或科研项目中的系统仿真验证。; 阅读建议：建议结合电力系统稳定性理论知识进行学习，先理解仿真模型各模块的功能与参数设置，再运行仿真并仔细分析输出结果，尝试改变故障类型或系统参数以观察其对稳定性的影响，从而深化对暂态稳定问题的理解。
这是一个基于Prisma和SQLite数据库构建的现代化轻量级且开箱即用的个人作品集展示平台后端服务系统_该项目核心功能包括用户认证授权作品数据模型管理文件上传存储以及提供标.zip
12-22
这是一个基于Prisma和SQLite数据库构建的现代化轻量级且开箱即用的个人作品集展示平台后端服务系统_该项目核心功能包括用户认证授权作品数据模型管理文件上传存储以及提供标.zip
基于PSO算法优化支持向量机参数的MATLAB仿真源码：SVM与PSO-SVM性能对比
12-22
本研究聚焦于运用MATLAB平台，将支持向量机（SVM）应用于数据预测任务，并引入粒子群优化（PSO）算法对模型的关键参数进行自动调优。该研究属于机器学习领域的典型实践，其核心在于利用SVM构建分类模型，同时借助PSO的全局搜索能力，高效确定SVM的最优超参数配置，从而显著增强模型的整体预测效能。 支持向量机作为一种经典的监督学习方法，其基本原理是通过在高维特征空间中构造一个具有最大间隔的决策边界，以实现对样本数据的分类或回归分析。该算法擅长处理小规模样本集、非线性关系以及高维度特征识别问题，其有效性源于通过核函数将原始数据映射至更高维的空间，使得原本复杂的分类问题变得线性可分。 粒子群优化算法是一种模拟鸟群社会行为的群体智能优化技术。在该算法框架下，每个潜在解被视作一个“粒子”，粒子群在解空间中协同搜索，通过不断迭代更新自身速度与位置，并参考个体历史最优解和群体全局最优解的信息，逐步逼近问题的最优解。在本应用中，PSO被专门用于搜寻SVM中影响模型性能的两个关键参数——正则化参数C与核函数参数γ的最优组合。 项目所提供的实现代码涵盖了从数据加载、预处理（如标准化处理）、基础SVM模型构建到PSO优化流程的完整步骤。优化过程会针对不同的核函数（例如线性核、多项式核及径向基函数核等）进行参数寻优，并系统评估优化前后模型性能的差异。性能对比通常基于准确率、精确率、召回率及F1分数等多项分类指标展开，从而定量验证PSO算法在提升SVM模型分类能力方面的实际效果。 本研究通过一个具体的MATLAB实现案例，旨在演示如何将全局优化算法与机器学习模型相结合，以解决模型参数选择这一关键问题。通过此实践，研究者不仅能够深入理解SVM的工作原理，还能掌握利用智能优化技术提升模型泛化性能的有效方法，这对于机器学习在实际问题中的应用具有重要的参考价值。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
jank_record_1766403318764055404.pb
12-22
jank_record_1766403318764055404.pb
分层模糊系统：梯度下降与递推最小二乘法联合辨识研究（Matlab代码实现）
12-22
分层模糊系统：梯度下降与递推最小二乘法联合辨识研究（Matlab代码实现）内容概要：本文围绕“分层模糊系统：梯度下降与递推最小二乘法联合辨识研究”展开，介绍了基于Matlab代码实现的分层模糊系统参数辨识方法。通过结合梯度下降法和递推最小二乘法，实现对系统结构和参数的高效联合辨识，提升模型精度与收敛速度。文中详细阐述了算法原理、实现步骤及仿真验证过程，展示了该方法在非线性系统建模与辨识中的有效性，适用于复杂动态系统的建模与控制研究。; 适合人群：具备一定Matlab编程基础和系统辨识理论背景的研究生、科研人员及自动化、控制工程等相关领域的技术人员。; 使用场景及目标：①应用于非线性动态系统的建模与参数辨识；②用于提高模糊系统训练效率与预测精度；③支持科研复现、算法优化及工程实际中的系统辨识任务； 阅读建议：建议读者结合提供的Matlab代码进行实践操作，深入理解两种优化算法的融合机制，并尝试在不同数据集或应用场景中进行迁移与改进，以掌握其核心思想与实现技巧。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值