Thread类相关方法

最新推荐文章于 2022-06-05 22:29:04 发布
最新推荐文章于 2022-06-05 22:29:04 发布
阅读量7k 收藏 1
点赞数 1
分类专栏： java 文章标签： java thread
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/czmacd/article/details/99590476
版权
Thread各状态

线程某时间点只能处于一种状态。这些状态是虚拟机状态，与操作系统线程状态无关。

  • NEW：线程尚未启动的状态，调用start之前
  • RUNNABLE：可运行、就绪状态，表示已经在JVM中执行，但是同一时间只有一线程获取到CPU资源，所以虽然在JVM层面多个线程一直处理RUNNABLE状态，但是在操作系统层面并不是真正得到CPU资源运行
  • BLOCKED：线程因为等待monitor锁而阻塞时的状态
  • WAITING：正在等待的线程的状态，有3种情况造成线程等待：1.Object.wait 2.Thread.join 3.LockSupport.park ；处于WATING状态的线程正在等待其它线程执行某种操作，例如，线程调用Object.wait()处于WAITING状态，那么它其它线程调用Object.notify或Object.notifyAll才会唤醒；线程调用ThreadA.join()后处于WAITING状态，那么它将等待ThreadA终止结束后才继续。
  • TIMED_WAITING：具有指定等待时间的等待线程的线程状态,1.Thread.sleep(long) 2.Object.wait(long) 3.Thread.join(long) 4.LockSupport.parkNanos(obj,long) 5.LockSupport.parkUntil(obj,long)
  • TERMINATED：线程已经完成执行的状态

PS:WAITTING线程是自己现在不想要CPU时间，但是BLOCKED线程是想要的，但是BLOCKED线程没有获得锁，所以轮不到BLOCKED线程，在操作系统层面上两种状态的线程都是处于"阻塞"状态

在这里插入图片描述

interrupt()的方法

interrupt()方法是唯一能将中断标记设置为 true 的方法

  1. 如果本线程是处于阻塞状态：调用线程的wait(), wait(long)或wait(long, int)会让它进入等待(阻塞)状态，或者调用线程的join(), join(long), join(long, int), sleep(long), sleep(long, int)也会让它进入阻塞状态。若线程在阻塞状态时，调用了它的interrupt()方法，那么它的“中断状态”会被清除并且会收到一个InterruptedException异常。例如，线程通过wait()进入阻塞状态，此时通过interrupt()中断该线程；调用interrupt()会立即将线程的中断标记设为true，但是由于线程处于阻塞状态，所以该中断标记会立即被清除为false，同时，会产生一个InterruptedException的异常。
  2. 如果线程被阻塞在一个Selector选择器中，那么通过interrupt()中断它时；线程的中断标记会被设置为true，并且它会立即从选择操作中返回。
  3. 如果不属于前面所说的情况，那么通过interrupt()中断线程时，它的中断标记会被设置为true。

测试线程在不同状态下时调用interrupt()的效果:

	@Test
	public void interrupteWhileThreadNew() {
		Thread t = new Thread();
		System.out.println(t.getState()); // NEW
		t.interrupt();
		System.out.println(t.isInterrupted()); // false
	}

	@Test
	public void interrupteWhileThreadTerminated() throws InterruptedException {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("thread terminated");
			}
		});
		t.start();
		t.join();
		System.out.println(t.getState()); // TERMINATED
		t.interrupt();
		System.out.println(t.isInterrupted()); // false
	}

	@Test
	public void interrupteWhileThreadRun() throws InterruptedException {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
				}
			}
		});
		t.start();
		System.out.println(t.getState()); // RUNNABLE
		t.interrupt();
		Thread.sleep(1000L);
		System.out.println(t.isInterrupted()); // true
	}

	/** 模拟因竞争锁而BLOCKED的线程 **/
	static class BlockedThread extends Thread {
		public static synchronized void test() { // MyThread类对象锁
			while (true) {
				// System.out.println("block method");
			}
		}

		@Override
		public void run() {
			test();
		}
	}

	@Test
	public void interrupteWhileThreadBlock() throws InterruptedException {
		BlockedThread t1 = new BlockedThread();
		t1.start();
		BlockedThread t2 = new BlockedThread(); // t2获取不到锁
		t2.start();
		Thread.sleep(1000);
		System.out.println(t2.getState()); // BLOCKED
		t2.interrupt();
		System.out.println(t2.isInterrupted()); // true
	}

	@Test
	public void interrupteWhileThreadWait() throws InterruptedException {
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(10000L); // 线程放弃资源挂起进入“阻塞”状态
				} catch (InterruptedException e) {
					System.out.println(e.getMessage()); // 线程阻塞时对中断操作敏感，抛出异常并清空中断标志位。
					System.out.println("线程被中断，标记位：" + Thread.currentThread().isInterrupted()); // false,切记在线程dead之前
				}
			}
		});
		t.start();
		Thread.sleep(1000L);
		System.out.println(t.getState()); // TIMED_WAITING
		t.interrupt();
	}

线程在未启动或者在已经结束之后调用interrupt()并不产生任何效果(标志位依然是false)，线程正在运行或者因为竞争锁BLOCKED时调用interrupt()可以如常把标志位设置为true

应该如何中断线程

stop()方法是一种野蛮的中断线程方法，如何合理地中断线程，应该结合中断机制，但Java中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理中断。通过上面的分析，知道了线程在调用interrupt()后总体上会产生两种情况：

  1. 当线程是RUNNABLE,BLOCKED状态或线程阻塞在Selector选择中，中断标记被设置为true
  2. 当线程因为wait(),join(),sleep()进入阻塞，会产生InterruptedException异常并清除标记位

所以在使用中断机制进行中断线程时要涵盖以上两种情况，假设线程不断循环做某件(while)且可能发生阻塞(当InterruptedException),如果线程只做某事一次且不会发生阻塞行为，那需要具体场景具体处理中断了：

@Override
public void run() {
    try {
        // 情况1. isInterrupted()保证，只要中断标记为true就终止线程。
        while (!isInterrupted()) {
            // do something...
        }
    } catch (InterruptedException ie) {  
        // 情况2. InterruptedException异常保证，当InterruptedException异常产生时，线程被终止。
    }
}
interrupted() 和 isInterrupted()的区别

interrupted() 和 isInterrupted()都能够用于检测对象的“中断标记”。
区别是，interrupted()除了返回中断标记之外，它还会清除中断标记(即将中断标记设为false)；而isInterrupted()仅仅返回中断标记。

isAlive()方法

线程在启动start之前或者dead之后isAlive()==false,线程dead有两种情况：

  1. 要么是自然原因，当线程的run方法正常退出时，线程自然死亡
  2. 要么是被kill，例如调用了线程的stop()方法或抛出一个未捕获的Exception或Error。
    stop方法向线程抛出一个ThreadDeath对象来终止它。因此，当线程以这种方式被终止时，它是异步终止的，线程将在实际接收ThreadDeath异常时才死亡，如果当时线程正在做一些敏感的计算，这样突然的停止可能会造成程序处于不一致的状态，所以不建议直接调用线程的stop方法，而应该安排一个更温和的终止，例如设置一个标志来指示run方法应该退出（第一种方式）。

image

join()方法

在线程A中触发线程B的join()方法：线程A将进入WAITING状态，让出CPU资源，等待B线程先执行完成

  public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {  //wait一般都在循环<条件>里，只有B线程alive就一直等待下去，因为A线程可能被线程C唤醒，此时A线程还alive
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

join方法是一个同步方法，通过wait/notifyAll实现。

  1. 在线程A中调用线程B的join()时，首先线程A会获取线程B对象锁
  2. 线程A持有线程B对象锁后，进入线程B的join方法内
  3. 判断线程B是否alive，如果是，则调用wait()，线程A释放B对象锁进入B对象锁wait set继续WAITING
  4. 当线程B不再alive时，会调用notifyAll，线程A被唤醒竞争线程B对象锁，成功后线程A往下执行（可能除了线程A，还有其它线程被唤醒）
sleep(int)方法

使当前执行的线程休眠(暂时停止执行)指定的毫秒数，期间让出CPU资源给其它线程，但是不会释放已获取到的锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。

yield()方法

把自己占有的cpu时间释放掉，然后和其他线程一起竞争(有可能还是自己竞争到CPU，区别于sleep)，很少使用该方法，可能对调试或测试有用

suspend()，resume()方法

suspend()很容易发生死锁，线程调用suspend()后，不会释放已经获取的资源锁，在线程挂起后且恢复(resume())之前，其它线程都无法访问这些资源，看起来，只要是在合适有时机对已经挂起的线程进行及时恢复程序就能朝理想的方向运行，这就引出另一个问题了，多线程的编程时很难控制每次都是对同一线程先挂起再恢复，如果挂起发生在恢复之后，那么该线程有可能一直处于挂起的状态，当把线程挂起时，线程状态居然还是RUNNABLE

	class MyThread extends Thread {
 		@Override
		public void run() {
			while (true) {
 			}
		}
	}
	@Test
	public void suspendThread() throws InterruptedException {
		MyThread t = new MyThread();
		t.start();
		Thread.currentThread().sleep(1000L);
		t.suspend();
		Thread.currentThread().sleep(1000L);
		System.out.println(t.getState()); //RUNNABLE
	}

我们不能通过线程状态来状态线程是否挂起，所以说suspend()天生是容易发生死锁的，除了自行扩展维护一个suspended的状态，好像判断不了线程是否当前被挂起？

  • 对比LockSupport.park()/parkNanos/parkUntil与LockSupport.unpark()

LockSupport被设计作为创建更高級別的同步工具，少用于并发控制应用，parkXXX()方法会阻塞当前线程，unpark(thread)方法会立即唤醒被阻塞的线程，让它从park方法处继续执行。

  1. park阻塞线程时相关的资源锁不会释放
  2. park阻塞的线程的线程状态为TIMED_WAITING/WAITING
  3. park阻塞的线程调用interrupt后，线程立即退出阻塞，从park处恢复执行，且不会擦除中断位，也无异常(区别于sleep)
  4. 不会出现像suspend()/resume()产生死锁情况，如果先调用unpark()再调用park()，线程会立即退出阻塞
	static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	static class MyThread extends Thread {
		public MyThread(String name) {
			this.setName(name);
		}

		@Override
		public void run() {
			synchronized (MyThread.class) {
				String name = Thread.currentThread().getName();
				System.out.println(sdf.format(new Date()) + " " + name + "-获取锁成功");
				LockSupport.parkNanos(5000000000L); // 阻塞5秒
				System.out.println(sdf.format(new Date()) + " " + name + "-park结束");
				System.out.println(sdf.format(new Date()) + " " + "thread1 中断标志为:" + Thread.currentThread().isInterrupted());// true中断位没被吞掉
			}
		}
	}

	/** 测试资源锁竞争 **/
	@Test
	public void test1() throws InterruptedException {
		MyThread t1 = new MyThread("thread1");
		MyThread t2 = new MyThread("thread2");
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		// 2019-08-22 16:31:01 thread1-获取锁成功
		// 2019-08-22 16:31:06 thread1-park结束
		// 2019-08-22 16:31:06 thread2-获取锁成功 //线程2等线程1执行完毕(5秒)才获取到锁
		// 2019-08-22 16:31:11 thread2-park结束
	}

	/** 测试线程状态 **/
	@Test
	public void test2() throws InterruptedException {
		MyThread t1 = new MyThread("thread1");
		t1.start();
		Thread.currentThread().sleep(2000L);
		System.out.println(sdf.format(new Date()) + " " + "thread1 park时的线程状态：" + t1.getState());
		t1.join();
		// 2019-08-22 16:32:24 thread1-获取锁成功
		// 2019-08-22 16:32:26 thread1 park时的线程状态：TIMED_WAITING
	}

	/** 先unpark再park **/
	@Test
	public void test3() throws InterruptedException {
		MyThread t1 = new MyThread("thread1");
		t1.start();
		LockSupport.unpark(t1);
		Thread.currentThread().sleep(2000L);
		t1.join();
		// 2019-08-22 16:39:09 thread1-获取锁成功
		// 2019-08-22 16:39:09 thread1-park结束 //线程没有park(5秒)

	}

	/** 测试中断响应 **/
	@Test
	public void test4() throws InterruptedException {
		MyThread t1 = new MyThread("thread1");
		t1.start();
		Thread.currentThread().sleep(2000L);
		t1.interrupt();
		// 2019-08-22 16:38:05 thread1-获取锁成功
		// 2019-08-22 16:38:07 thread1-park结束
		// 2019-08-22 16:38:07 thread1 中断标志为:true //中断标记没被擦除
	}
参考

https://www.jianshu.com/p/ceb8870ef2c5
https://www.cnblogs.com/skywang12345/p/3479949.html
https://benjaminwhx.com/2018/05/01/%E3%80%90%E7%BB%86%E8%B0%88Java%E5%B9%B6%E5%8F%91%E3%80%91%E8%B0%88%E8%B0%88LockSupport/

矛始
关注
专栏目录
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1925
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
Java继承Thread类创建线程类示例
08-25
Java继承Thread类创建线程类是Java线程编程中的一种常见方法。通过继承Thread类，可以创建自定义的线程类，并重写run方法来实现线程的执行体。本文将通过实例形式，详细介绍Java继承Thread类创建线程类的步骤和注意...
Thread类的常用方法
听雨居
11-05 488
String getName()　　返回该线程的名称。void setName(String name)　　改变线程名称，使之与参数 name 相同。int getPriority() 　　返回线程的优先级。void setPriority(int newPriority) 　　更改线程的优先级。boolean isDaemon() 　　测试该线程是否为守护线程。void setDaemon(boo
Thread类方法介绍
chenrenxiang的专栏
08-12 464
1. sleep Thread.sleep(long millis) 值不能为负值，否则会抛 IllegalArgumentException 异常 Thread.sleep(long millis, int nanos) 可以传入纳米时长，更精准控制时间，nanos取值范围为(0-999999) 调用Thread.sleep()方法会使线程调度器把当前线程至于TIMED_WAITING状态...
Thread类常用方法
weixin_34018202的博客
07-14 141
/** Thread类的常用方法:* 1.run():当前线程执行的操作，要书写在run()中* 2.start():启动线程并执行相应的run()* 3.currentThread():获取当前的线程* 4.getName():获取当前线程的名字* 5.setName(String name):设置当前线程的名字* 6.yield():释放当前线程对cpu的占...
Thread类常用的方法
qq_44840148的博客
08-07 1296
文章目录1. run()与start()方法：启动线程2. get方法：获取线程标识3. currentThread()方法:返回对当前正在执行的线程对象的引用 1. run()与start()方法：启动线程 使用继承 Thread 类的方法创建新线程 从运行结果我们可以看出：虽然步骤1在步骤2前面，但是步骤2却比步骤1先执行完。 这是因为 start()方法的执行比较耗时，底层有如下过程： 1）通过 JVM 告诉操作系统创建线程 Thread 2）操作系统开辟内存并调用系统函数创建 Thre
Thread类的有关方法
qq_46112274的博客
06-05 4162
多线程
对python:threading.Thread类的使用方法详解
09-19
2. **实例化Thread类** 当实例化`Thread`时，可以设置线程的名字、回调目标、参数等，例如： ```python t = threading.Thread(name='my_thread', target=my_function, args=(param1, param2)) ``` 其中，`name`...
thread 类
07-26
接下来，我将详细讲解`Thread`类的相关知识点。 1. **线程的概念**： 在计算机系统中，线程是程序执行的基本单位，一个进程可以包含多个线程，它们共享同一进程的资源，但各自拥有独立的程序计数器、栈和局部变量...
c++11封装thread库的方法示例
12-31
本文将给大家详细介绍关于c++11封装thread库的相关内容，下面话不多说了，来一起看看详细的介绍吧 基本接口要求 要求std::thread的构造函数 template explicit thread( Function&& f, Args&&... args ); 但是OS的...
Thread中相关方法
yjh1271845364的博客
06-28 181
调用thread的start方法，由下面代码可以看出构造方法是由main线程调用的，而run()方法是由Thread-0线程调用的 从下面代码可以看出，都是main线程调用的 调用thread的run()并不是启动线程，而是就是单纯的调用这个方法，isAlive()测试这个线程是否活着。 如果一个线程已经启动并且尚未死亡，那么线程是活着的。 由于调用run()方法并不...
Thread类中相关方法
小汤圆
03-15 58
这些人，绝了
Thread相关方法介绍
yjs1129580545的专栏
02-22 265
1、Object.wait(),Object.notify() 作用：当在一个线程内调用object.wait方法后，这个线程会释放掉当前持有的对象锁，直到调用object.notify方法唤醒。 注意事项：需要在synchronized同步块中执行。 例子：final Object o = new Object(); Thread t1 = new Thread(new Ru
Thread类方法
weixin_39827145的博客
06-17 281
Thread Thread.currentThread() ：获得当前线程的引用。获得当前线程后对其进行操作。 Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() ：返回线程由于未捕获到异常而突然终止时调用的默认处理程序。 int Thread.activeCount()：当前线程所在线程组中活动线程的数目。 v...
Thread类的方法
Liangshuaitao114的博客
12-04 454
一、常用方法 static Thread currentThread() 返回对当前正在执行的线程对象的引用。 long getId()返回该线程的标识符。 String getName()返回该线程的名称。 int getPriority() 返回线程的优先级。 void interrupt() 中断线程。 boolean isAlive()测试线程是否处于活动状态。 void j...
Thread类中的一些方法
阿振的博客
01-30 895
1.yield:  让步，表示当前线程愿意让出CPU资源给其他线程。而这种让步，不是绝对的，有可能执行了yield方法后，当前线程并没有真正让出CPU资源。 /** * A hint to the scheduler that the current thread is willing to yield * its current use of a processor. The sched
thread类的start方法实现
最新发布
03-26
start方法是Thread类的重要方法之一，它的作用是启动一个线程并使它进入“就绪”状态。start方法的实现如下： 1. 首先判断当前线程是否为“新建”状态，只有“新建”状态的线程才能被启动，否则会抛出IllegalThreadStateException异常。 2. 将当前线程加入执行队列中，并调用native方法start0()启动线程。 3. start0()方法会在新的线程中执行run()方法。 代码实现如下： ``` public synchronized void start() { if (threadStatus != 0) throw new IllegalThreadStateException(); group.add(this); boolean started = false; try { start0(); started = true; } finally { if (!started) { group.threadUnmap.remove(this); threadStatus = 0; } } } ``` 其中，start0()方法是一个本地方法，由Java虚拟机实现，它的实现方式与操作系统有关。在Windows平台下，start0()方法会使用Win32 API函数CreateThread()创建一个新线程；在Linux平台下，start0()方法会使用pthread_create()函数创建一个新线程。需要注意的是，由于start0()方法是一个本地方法，因此它是不可见的，我们无法在Java中直接调用它。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值