怎么查看线程状态

1. jps指令查看我当前的进程ID
2. jstack 线程ID

示例：

public class StatusDemo {
	public static void main(String[] args) {
		new Thread(()->{
			while(true) {
				LockSupport.park();
			}
		},"huihui_waiting").start(); //阻塞状态
		new Thread(()->{
			try {
				Thread.sleep(100000);
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		},"huihui_time_waiting").start(); //阻塞状态
	new Thread(new BlockClass(),"huihui_thread").start();
	new Thread(new BlockClass(),"huihui_block").start();
	}
	static class BlockClass extends Thread{
		public void run(){
			synchronized(BlockClass.class){
				try{
					Thread.sleep(1000000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

查看状态：

1. jps指令得到我程序的进程信息
   
   得到我当前的进程为20376
2. 通过jstack 20376得到线程的状态信息
   

线程终止

刚才我们讲过，一个线程里面任务正常执行完毕，状态就是TERMINATED，就是终止状态。
但是，如果我线程里面的任务一直没有执行完成，我想去终止这个线程，或者我给点信息给到线程里，告诉线程我想终止结束呢！
所以我可以强制去关闭线程：线程提供一个stop方法，该方法不建议使用，已经过时了！！

因为stop是强行关闭线程，线程里面的任务都不在执行，不管线程的任务是否执行成功与否，就算执行到一半也会强制关闭！导致很多不可控制的
结果，比如支付付一半等等！！

所以我们要需要去优雅的关闭。什么叫做优雅关闭，就是我告诉你，我需要关闭了，但是我不强制关闭

线程里面提供了interrupt来优雅关闭，示例如下

package thread.demo.interrupt;
public class InterruptTest implements Runnable{
	@Override
	public void run() {
		while (!Thread.currentThread().isInterrupted()) {
		//false
			try {
				Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
					System.out.println("异常里的isInterrupted:"+Thread.currentThread().isInterrupted());
					Thread.currentThread().interrupt(); //再次中断
					System.out.println("再次中断："+Thread.currentThread().isInterrupted());
				}
			}
		System.out.println("线程结束");
	}
	public static void main(String[] args) throws InterruptedException {
		Thread t1=new Thread(new InterruptTest());
		t1.start();
		Thread.sleep(1000);
		//不中断，线程不进异常不中断，中断，线程会进入异常并且复位
		t1.interrupt();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

其思想：有个共享变量 类型boolean的isInterrupted，默认是false，然后外面可以改成true，线程里面可以获取到状态，如果是true，那么就说明外面有人想要我中断，那么如果我当前是waiting或者timewaiting状态，就会唤醒我的线程进入InterruptedException异常！！

interrupt()、interrupted()、isInterrupted()的作用以及区别在哪？

• interrupt() 优雅的通知线程需要结束，如果线程在waiting 会抛出InterruptedException，线程自己决定要不要结束，异常会触发复位

• isInterrupted()获取线程的中断标记，但是不会进行复位操作

• interrupted()获取线程的中断标记，并且主动执行复位操作

interrupted()示例如下：

public static void main(String[] args) throws InterruptedException {
	Thread.currentThread().interrupt();
	System.out.println(Thread.interrupted()); //返回true，当前线程被interrupt
	System.out.println(Thread.currentThread().isInterrupted()); //获取线程的interrupt状态，本来应该是true，但是interrupted触发了复位，为false
}
1
2
3
4
5

线程状态的定义

其实Thread类下有JAVA层面对Thread状态的定义：

public enum State {
	/**
	* Thread state for a thread which has not yet started.
	*/
	NEW,
	/**
	* Thread state for a runnable thread. A thread in the runnable
	* state is executing in the Java virtual machine but it may
	* be waiting for other resources from the operating system
	* such as processor.
	*/
	RUNNABLE,
	/**

	* Thread state for a thread blocked waiting for a monitor lock.
	* A thread in the blocked state is waiting for a monitor lock
	* to enter a synchronized block/method or
	* reenter a synchronized block/method after calling
	*{@link Object#wait() Object.wait}.
	*/
	BLOCKED,
	/**
	* Thread state for a waiting thread.
	* A thread is in the waiting state due to calling one of the
	* following methods:
	* <ul>
	* <li>{@link Object#wait() Object.wait} with no timeout</li>
	* <li>{@link #join() Thread.join} with no timeout</li>
	*<li>{@link LockSupport#park() LockSupport.park}</li>
	* </ul>
	*
	* <p>A thread in the waiting state is waiting for another thread to
	* perform a particular action.
	*
	* For example, a thread that has called <tt>Object.wait()</tt>
	* on an object is waiting for another thread to call
	* <tt>Object.notify()</tt> or <tt>Object.notifyAll() </tt> on
	* that object. A thread that has called <tt>Thread.join()</tt>
	* is waiting for a specified thread to terminate.
	*/
	WAITING,
	/**
	* Thread state for a waiting thread with a specified
	waiting time.
	* A thread is in the timed waiting state due to
	calling one of
	* the following methods with a specified positive
	waiting time:
	* <ul>
	* <li>{@link #sleep Thread.sleep}</li>
	* <li>{@link Object#wait(long) Object.wait} with timeout</li>
	*<li>{@link #join(long) Thread.join} with timeout</li>
	*<li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
	*<li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
	*
	</ul>
	*/
	TIMED_WAITING,
	/**
	* Thread state for a terminated thread.
	* The thread has completed execution.
	*/
	TERMINATED;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

其实我们想一下，任何东西的生命周期都是开始与死亡！！
所以线程肯定有2种状态
初始（NEW）
新创建了一个线程对象，但是没有调用start()方法
终止（TERMINATED）
这个线程执行完毕
除了这2种状态外，线程还有以下几种状态
运行（RUNNABLE）
我们线程开启是需要start 的,所以初始化后，有个运行状态
等待（WAITING）
进入该状态的线程需要等待其他线程做出一些特定动作，线程进入了这个状态一般调用了

• Object.wait() 需要等待另一个线程执行Object.notify()或者Object.notifyAll()
• Thread.join() 需要等待线程执行完成
• jpsLockSupport.park(） 等待执行LockSupport.unpark(thread)

超时等待（TIMED_WAITING）
指定了时间后自行返回，等待一段时间后，会唤醒线程，而不是永久等待，一般执行过

• Thread.sleep(long)
• Object.wait(long)
• Thread.join(long)
• LockSupport.parkNanos()
• LockSupport.parkUntil()

阻塞（BLOCKED）
线程阻塞于锁，比如synchronized