详述Java中线程常用方法

最新推荐文章于 2023-02-14 22:18:04 发布
最新推荐文章于 2023-02-14 22:18:04 发布
阅读量122 收藏
点赞数
文章标签： Java最后一天
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingmeilucha/article/details/100135966
版权

•join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 如下：

​
import java.util.Date;
import java.text.SimpleDateFormat;

public class Test {

	public static void main(String[] args) {
		TimeThread thread = new TimeThread();
		thread.start();//还可以写成：new TimeThread().start();
		CountThread countThread = new CountThread(thread);
		countThread.start();
	}
}//主方法

class TimeThread extends Thread {//类时间线程
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println("实践2##" + new Date());
			try {
				sleep(10000000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class CountThread extends Thread {//类计数线程
	TimeThread timeThread;

	CountThread(TimeThread timeThread) {//有参构造方法
		this.timeThread = timeThread;//调用全局变量
	}

	@Override
	public void run() {//重写方法
		for (int i = 0; i < 50; i++) {
			System.out.println("技术1￥￥￥" + i);
			if (i == 2) {
				try {
					timeThread.join();// 执行join方法的线程堵塞，知道调用join方法的线程执行完毕//此处也可以不用创建全局变量再次调用，直接：new TimeThread().start();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

​

解释上面join（）方法：当循环执行到i为2时该行代码执行，CounterThread所创建线程进入阻塞状态，直到timeThread变量所对应线程结束， CounterThread所创建线程才能再次进入就绪状态，进而进入执行状态。

注意：1.线程对象在调用join方法前必须先调用start方法，否则该线程永远不会进入执行状态。

•interrupt方法：结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态，并在调用wait、join和sleep方法处产生InterruptedException异常。

import java.util.Date;
import java.text.SimpleDateFormat;

public class Test {

	public static void main(String[] args) {
		TimeThread thread1 = new TimeThread();
		thread1.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		thread1.interrupt();//调用方法，使之堵塞
	}
}

class TimeThread extends Thread {
	@Override
	public void run() {
		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss:sss");
		String beforeTime = sdf.format(new Date());
		System.out.println("beforeTime: " + beforeTime);
		try {
			sleep(300000);
		} catch (InterruptedException e) {
			System.out.println("程序捕获异常！");
		}
		String afterTime = sdf.format(new Date());
		System.out.println("afterTime: " + afterTime);
	}
}

解释上面：理论上beforeTime和afterTime应该相差30秒，但因为该线程类的对象在1秒后执行了interrupt方法而使得该线程对象提前结束了阻塞状态，从而导致了beforeTime和afterTime相差少于30秒

*currentThread方法：返回当前正在执行的线程对象。

import java.util.Date;
import java.text.SimpleDateFormat;

public class Test {

	public static void main(String[] args) {
		TimeThread thread1 = new TimeThread();
		thread1.start();
		CountThread countThread = new CountThread(thread1);
		System.err.println(countThread);
		countThread.start();
	}
}

class TimeThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 50; i++) {
			System.out.println("实践2##" + new Date());
			try {
				sleep(100000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class CountThread extends Thread {
	TimeThread timeThread;

	CountThread(TimeThread timeThread) {
		this.timeThread = timeThread;
	}

	@Override
	public void run() {
		Thread thread=Thread.currentThread();
		System.out.println(thread);
		for (int i = 0; i < 50; i++) {
			System.out.println("技术1￥￥￥" + i);
//			if (i == 2) {
//				try {
//					timeThread.join();// 执行join方法的线程堵塞，知道调用join方法的线程执行完毕
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}
//			}
		}
	}
}

如果是输出对象的getName()方法结果是一样的。下面是四个程序：

​
​
import java.util.Date;
import java.text.SimpleDateFormat;

public class Test {

	public static void main(String[] args) {
		Thread thread = new Thread();//这俩行也可以：Thread thread=thread.currentThread();
		Thread thread2 = thread.currentThread();// 此处等效于：
    /**public class Test {

	public static void main(String[] args) {
		Thread thread = new TimeThread();
		System.out.println(thread);
		thread.start();
	}
}

class TimeThread extends Thread{

	@Override
	public void run() {
		Thread thread = Thread.currentThread();
		System.out.println(thread);
	}
}*/
		System.out.println(thread2);
		TimeThread thread1 = new TimeThread();
		System.out.println(thread1);// 此处用了方法
		thread1.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		thread1.interrupt();
	}
}

class TimeThread extends Thread {
	@Override
	public void run() {
		TimeThread thread = (TimeThread) TimeThread.currentThread();
        //等效：Thread thread=timeThread.currentThread();
		System.out.println(thread);// 此处用了方法
		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss:sss");
		String beforeTime = sdf.format(new Date());
		System.out.println("beforeTime: " + beforeTime);
		try {
			sleep(300000);
		} catch (InterruptedException e) {
			System.out.println("程序捕获异常！");
		}
		String afterTime = sdf.format(new Date());
		System.out.println("afterTime: " + afterTime);
	}
}

class CountThread extends Thread {
	TimeThread timeThread;

	CountThread(TimeThread timeThread) {
		this.timeThread = timeThread;
	}

	@Override
	public void run() {
		Thread thread = Thread.currentThread();
		System.out.println(thread);
		for (int i = 0; i < 50; i++) {
			System.out.println("技术1￥￥￥" + i);
		}
	}
}

​

​
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {

	public static void main(String[] args) {
		new TimeThread().start();
	}
}
class TimeThread extends Thread{

	public TimeThread(){
		super("时间线程");
	}
	@Override
	public void run() {
		printTime();
	}
	
	public void printTime(){
		Thread thread = Thread.currentThread();
		String time = new SimpleDateFormat("HH:mm:ss").format(new Date());
		System.out.println(thread.getName()+"，当前时间："+time);
		System.out.println(thread.getName()+"，当前时间："+time);

	}
}
结果：
时间线程，当前时间：15:12:51
时间线程，当前时间：15:12:51



public class Test {

	public static void main(String[] args) {
		TimeThread timeThread = new TimeThread();
		System.out.println("########"+timeThread);
		timeThread.start();
		
		timeThread.run();
	}
}

class TimeThread extends Thread{

	@Override
	public void run() {
		Thread thread = Thread.currentThread();
		System.out.println("@@@@@@@@"+thread);
	}
}
结果：
########Thread[Thread-0,5,main]
@@@@@@@@Thread[main,5,main]
@@@@@@@@Thread[Thread-0,5,main]

调用方法isAlive():：判定该线程是否处于就绪、运行或阻塞状态，如果是则返回true，否则返回false。

注意：•线程A执行“已死”线程B所调用的jion方法，则线程A不会阻塞。

​
import wo.T;

public class Test {

	public static void main(String[] args) {
		//isAlive是否存活
		Thread thread=Thread.currentThread();
		TimeThread timeThread = new TimeThread(thread);
		System.out.println("########"+thread.isAlive());
		timeThread.start();
	}
}

class TimeThread extends Thread{
	Thread thread;
	public TimeThread(Thread thread) {
			 this.thread=thread;
		 }
	
	@Override
	public void run() {
		try {
			sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("$$$$$$$"+thread.isAlive());
	}
}
结果：//因为时间线程堵死了
########true
$$$$$$$false


​为例子一

 

public class Test {

	public static void main(String[] args) {
		Thread thread = Thread.currentThread();
		new PrintThread(thread).start();
		System.out.println("main线程状态："+thread.isAlive());
	}
}

class PrintThread extends Thread{

	private Thread thread;
	
	public PrintThread(Thread thread){
		this.thread = thread;
	}
	
	@Override
	public void run() {
		try {
			sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.err.println("main线程状态："+thread.isAlive());
	}
}
为例子二：
public class Test{
	
	String currentTime;
	
	public static void main(String[] args) {
		Test watch = new Test();
		TimeThread timeThread = watch.new TimeThread ();
		timeThread.start();
		watch.new DisplayThread(timeThread).start();
	}

	class DisplayThread extends Thread{

		TimeThread timeThread;
		public DisplayThread(TimeThread timeThread) {
			this.timeThread = timeThread;
		}
		
		@Override
		public void run() {
			System.out.println("时间线程状态："+timeThread.isAlive());
			try {
				sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("时间线程状态："+timeThread.isAlive());//显示器线程阻塞500毫秒，则时间线程“必死”
			try {
				timeThread.join();//显示器线程执行“已死”时间线程调用的jion方法，显示器线程不会阻塞
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(currentTime);
		}
	}

	class TimeThread extends Thread{
		@Override
		public void run() {
			currentTime = new java.util.Date().toString();
		}
	}
}
结果：
时间线程状态：true
时间线程状态：false
Thu Aug 29 15:52:42 CST 2019
为例子三

下面这个不太懂为什么这个结果： 仅多加了一条时间线程的run():

import wo.T;

public class Test {

	public static void main(String[] args) {
		//isAlive是否存活
		Thread thread=Thread.currentThread();
		TimeThread timeThread = new TimeThread(thread);
		System.out.println("########"+thread.isAlive());
		timeThread.start();
		timeThread.run();
	}
}

class TimeThread extends Thread{
	Thread thread;
	public TimeThread(Thread thread) {
			 this.thread=thread;
		 }
	
	@Override
	public void run() {
		try {
			sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("$$$$$$$"+thread.isAlive());
	}
}
结果：
########true
$$$$$$$true
$$$$$$$true

调用守护方法setDaemon()：

•setDaemon方法：用于将一个尚未调用线程start方法的线程设置为守护线程。守护线程主要用于为其他线程的运行提供服务（Java中的垃圾回收机制就是守护线程），这种线程属于创建它的线程。

•注意：守护线程随着最后一个非守护线程的终止而终止，如下代码： 

public class Test {

	public static void main(String[] args) {
		TimeThread timeThread = new TimeThread();
		timeThread.setDaemon(true);
		timeThread.start();/**线程对象调用start之前调用setDaemon且值设为true，该线程为守护线程，即随着进程中最后一个非守护线程的结束而结束。*/
		try {
			timeThread.sleep(12);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class TimeThread extends Thread{

	@Override
	public void run() {
		while(true) {
		System.out.println(111);
		}
	}
}
结果是在这12秒内非守护线程在沉睡，自然守护线程时间线程继续进行，知道一起终结。

注意：进程中所启动的其他非守护线程不会随着某一个非守护线程的结束而结束。

其他方法：

•void start()：使该线程开始启动，Java 虚拟机负责调用该线程的 run() 方法。多次启动一个线程是非法的。

•void sleep(long millis)：Thread类静态方法，线程进入阻塞状态，在指定时间（单位为毫秒）到达之后进入就绪状态（Runnable），而非立即进入执行状态。

•void yield()：静态方法，当前线程放弃占用CPU资源，回到就绪状态，使其他优先级不低于此线程的线程有机会被执行。

•void setPriority(int newPriority)：设置当前线程的优先级，线程优先级越高，线程获得执行的次数越多，Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

1.static int MAX_PRIORITY   最高优先级值为10；

2.static int NORM_PRIORITY   默认优先级值为5；

3.static int MIN_PRIORITY   最低优先级值为1；

注意：同一个线程类创建的多个线程，线程优先级越高的线程获得的执行次数极有可能越多；但是不同线程类创建的线程，线程优先级越高，执行次数不一定越多，这个run方法的代码复杂度有关。

•int getPriority()：获得当前线程的优先级。

import java.util.Date;

public class Test {

	public static void main(String[] args) {
		CounterThread countThread = new CounterThread("线程一");
		countThread.start();
		TimeThread timeThread = new TimeThread("线程二%%%%%%%%%%%%%%%%%");
		timeThread.setPriority(6);
		timeThread.start();
	}
}

class TimeThread extends Thread{

	@Override
	public void run() {
		while(true) {
		System.out.println(getName()+new Date());
		}//此时虽然时间线程优先级高，但代码较复杂，不一定获得执行次数就多
	}
	TimeThread(String name){
		super(name);
	}
}

class CounterThread extends Thread{

	@Override
	public void run() {
		while(true) {
		System.out.println(getName()+1111);
		}
	}
	CounterThread(String name){
		super(name);
	}
}//所以用此方法时还是要想看是不是同一个类创建的，如果不是，设定优先级也没有太大的作用。

 

 

漫�
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java初学之多线程（二）【常用方法】
qq_39676433的博客
08-24 215
join方法： 执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 我们看这样一段代码—— import java.util.Date; public class join { public static void main(String[] args) { TimeThread timeThread = new TimeThread(); time...
线程（二）常用方法详述
徐冰的博客
08-23 286
方法小结： 方法 作用 join() 执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 interrupt() 结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态，并在调用wait、join和sleep方法处产生InterruptedException异常。 currentThread() 返回当前正...
【JAVA】一个方法中多个线程new Thread(....).run()会发生啥呢
superKusch的博客
01-30 1024
根据上面说的，直接调用run方法，效果其实就是普通代码块，并没有以多线程的方式执行，所以输出 A B。A线程sleep的时间比B长，所以输出结果是 B A。
线程1——简述线程及线程池
YJT180的博客
08-24 189
程序，进程，线程的概念 •程序(Program)是为实现特定目标或解决特定问题而用计算机语言（比如Java语言）编写的命令序列的集合。 这就是一个程序 •进程（process）指一个程序的一次执行过程。 public class Hello { public static void main(String[] args) { try { Thread.sleep(1...
java线程（二）——常用方法
ANFO的博客
08-23 183
一.join（） join方法的作用是，执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 在如下代码中： 第9、10行：创建TimeThread线程对象，并开启该线程。 第11、12行：在主线程中使用for循环执行五次，打印五行简单数据。 第13行：当for循环执行到第三次的时候用timeThread线程对象调用join对象，此时由于该行代码是主线程执行的，...
flex详述和js常用方法
04-22
项目中应用到的css和js方法,优化代码
java线程笔记
06-06
详述java线程！！！
详述ASP.Net中页面之间传参方法
01-20
ASP.NET提供了卓越的事件驱动编程模型，让开发者简化了应用程序的总体设计，但是这个也造成了它固有的一些问题，例如，使用传统的ASP里，我们可以通过使用POST方法很容易地实现页面间传递值，同样的事情，在使用事件...
Java 中的字符串常量池详解
09-01
本文主要介绍Java中的字符串常量池的知识，这里整理了相关资料及简单示例代码帮助大家学习理解此部分的知识，有需要的小伙伴可以参考下
Java API接口详述.rar
12-08
全网最全的Java各种类和接口详细描述，能够帮助开发者了解Java的各个类和接口属性特点，属于公司内部开发手册，作为Java开发必不可少的资料，尤其对新手开发很有帮助。
多线程服务器
qq_45303986的博客
02-14 783
服务器端使用多线程的方式，当有客户端请求到达时，服务器将启动一个新线程为它返回当前的时间，服务完后线程自动销毁，服务器端会显示连接的次数。客户端比较简单，先搭建客户端。
线程池的使用简介
站在搜素引擎上的巨人
09-20 445
项目中涉及到了线程池的使用，最初使用的是Executors的工厂模式向我们提供了4种线程池实现方式，但是阿里的编码规约并不推荐使用，原因是使用Executors创建线程池不会传入这个参数而使用默认值所以我们常常忽略这一参数，而且默认使用的参数会导致资源浪费，不可取。 阿里的 Java开发手册，上面有线程池的一个建议： 【强制】线程池不允许使用 Executors 去创建，...
线程休眠,礼让
weixin_45970171的博客
11-02 726
线程休眠,礼让 线程休眠 sleep(时间)指定当前线程阻塞的毫米值 sleep存在异常InterruptedException; sleep时间达到后线程进入就绪状态 sleep可以模拟网络延迟（就是在run方法中加一个sleep方法就可以了），倒计时等 每一个对象都有一个锁，sleep不会释放锁； package com.Jinone.www; import java.text.SimpleDateFormat; import java.util.Date; public class TextS
Thread.sleep()的简单用法
Wyh824的博客
06-19 2777
要用sleep的目的：为了暂停当前线程，减缓当前线程的执行。如果有调用其他接口进行操作，可避免被误认为是恶意攻击。
java 函数睡眠10秒,Windows 10上的Java Thread.sleep()在S3睡眠状态下停止
weixin_34603528的博客
03-20 1603
有一个桌面应用程序使用Thread.sleep()来实现长(几分钟或几小时)延迟.这个应用程序从Windows XP到(至少)Windows 7都运行良好.应用程序计算未来需要做多少事情,然后点击Thread.sleep(msToWait).即使系统在等待期间恰好进入S3睡眠状态,这一直工作正常.但是,从Windows 10开始,如果机器已经在S3中,则Thread.sleep()之后的代码不会“...
java多线程实现方式一——继承(extends)Thread类
程序员资料站
08-06 7745
基本思想：  在子类中重新实现父类中的run()方法，然后在使用多线程的时候调用start()方法，则系统会自动调用run()方法。 实现类： package com.ysu.test; public class Thread1 extends Thread{ private String name; public Thread1(String name) { this.nam...
Java Thread 实现方式
time_knight的博客
05-09 8516
       关于Thread有一个比较有趣的面试题。当你new 一个Thread的时候，直接调用它的run()方法，run()会执行在哪个线程？ 答案是调用run()的线程，因为只有在调用start()之后，Java才会创建一个新的线程，然后新的线程再调用执行Java代码里面的run()。看如下代码，一个简单的实现：Thread thread = new Thread(){ public...
详述线程（二）—— 线程常用方法
飞翔的企鹅的博客
08-23 191
线程系列传送门： 详述线程（一）——了解线程 详述线程（二）—— 线程常用方法（本篇） 详述线程（三）—— 数据共享 详述线程（四）—— 线程协作 1、join方法 作用：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 注意：...
详述java获得反射的三种方法
最新发布
07-16
当需要在运行时动态地获取类的信息、调用类的方法或访问类的属性时，可以使用Java的反射机制。下面是Java中获得反射的三种常见方法： 1. 使用Class类的forName()方法：通过完整类名获取类的Class对象。 ```java Class<?> clazz = Class.forName("com.example.MyClass"); ``` 2. 使用对象的getClass()方法：通过已存在的对象获取类的Class对象。 ```java MyClass obj = new MyClass(); Class<?> clazz = obj.getClass(); ``` 3. 直接通过类名.class获取Class对象：直接使用类名加上.class后缀获取类的Class对象。 ```java Class<?> clazz = MyClass.class; ``` 这些方法都会返回一个Class对象，通过该对象可以获取类的信息、调用方法和访问属性。例如，可以使用Class对象来创建新的实例、调用方法和获取字段值等。 需要注意的是，使用反射机制可能会带来性能上的损失，并且会破坏封装性。因此，在使用反射时应慎重考虑，并确保了解其使用场景和适用性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值