java线程状态及线程相关常用方法

创建线程与查看

• 继承Thread类重写run方法

class PrimeThread extends Thread {
   
   
    long minPrime;
    PrimeThread(long minPrime) {
   
   
        this.minPrime = minPrime;
    }
    public void run() {
   
   

    }
}

 PrimeThread p = new PrimeThread(143);
 p.start();

• 实现Runnable接口

class PrimeRun implements Runnable {
   
   
    long minPrime;
    PrimeRun(long minPrime) {
   
   
        this.minPrime = minPrime;
    }

    public void run() {
   
   
        // compute primes larger than minPrime
        . . .
        }
}

PrimeRun p = new PrimeRun(143);
new Thread(p).start();   

小结

• 方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
• 用 Runnable 更容易与线程池等高级 API 配合
• 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

查看线程

windows下

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• tasklist 查看进程
• taskkill 杀死进程

tasklist | findstr java

# 根据端口号找到进程号
netstat -aon|findstr "8080"
taskkill /pid 4136-t -f

linux下

• ps -ef 查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill杀死进程
• top 按大写 H 切换是否显示线程
• top -H -p 查看某个进程（PID）的所有线程

java进程查方式

• jps 命令查看所有 Java 进程
• jstack 查看某个 Java 进程（PID）的所有线程状态
• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

线程状态

从操作系统层面来看，有五种状态

• 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
• 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
• 【运行状态】指获取了 CPU 时间片运行中的状态
  • 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
• 【阻塞状态】
  • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑 调度它们
• 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

从Java API层面来看，一共有六种状态

Java语言定义了6种线程状态（Thread.state中定义），在任意一个时间点中，一个线程只能有且只有其中的一种状态，并 且可以通过特定的方法在不同状态之间转换。这6种状态分别是：

• 新建（NEW）：创建后未启动的线程（没有调start方法）
• 运行（Runnable）：包括操作系统线程状态中的Running和Ready,操作系统执行阻塞api(如读取文件)时，也是显示处于该状态，也就是处于此状态的线程有可能正在执行，也有可能正在等待着操作系统为它分配执行时间。
• 无限期等等（Waiting）：处于这种状态的线程不会被分配处理器执行时间，它们要等待被其他线程显式唤醒。以下方法会让线程陷入无限期的等待状态：
  • 没有设置Timeout参数的Object::wait方法
  • 没有设置Timeout参数的Thread::join方法
  • LockSupport::park()方法
• 限期等待（Timed Waiting）：处于这种状态的线程也不会被分配处理器执行时间，不过无须等待被其他线程显式唤醒，在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态：’
  • Thread::sleep()方法；
  • 设置了Timeout参数的Object::wait()方法；
  • 设置了Timeout参数的Thread::join()方法；
  • LockSupport::parkNanos()方法；
  • LockSupport::parkUntil()方法。
• 阻塞（Blocked）:线程被阻塞了，“阻塞状态”与“等待状态”的区别是“阻塞状态”在等待着获取到一个排它锁，这个事件将在另外一个线程放弃这个锁的时候发生；而“等待状态”则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
• 结束（Terminated）:已终止线程的线程状态，线程已经结束执行。

通过代码查看

public class ThreadState {
   
   
    public static void main(String[] args) {
   
   
        new Thread(new TimeWaiting(), "TimeWaitingThread").start();
        new Thread(new Waiting(), "WaitingThread").start();
        new Thread(new Blocked(), "BlockedThread-1").start();
        new Thread(new Blocked(), "BlockedThread-2").start();
    }


    static class Blocked implements Runnable {
   
   
        @Override
        public void run() {
   
   
            synchronized (Blocked.class) {
   
   
                while (true) {
   
   
                    SleepUtils.second(100);
                }
            }
        }
    }

    static class Waiting implements Runnable {
   
   
        @Override
        public void run() {
   
   
            while (true) {
   
   
                synchronized (Waiting.class) {
   
   
                    try {
   
   
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
   
   
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    static class TimeWaiting implements Runnable {
   
   
        @Override
        public void run() {
   
   
            while (true) {
   
   
                SleepUtils.second(100);
            }
        }
    }
}

public class SleepUtils {
   
   
    public static final void second(long seconds) {
   
   
        try {
   
   
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
   
   
        }
    }
}

打印结果，或通过jps和jstack命令查看

@Slf4j(topic = "c.TestState")
public class TestState {
   
   
    public static void main(String[] args) throws IOException {
   
   
        Thread t1 = new Thread("t1") {
   
   
            @Override
            public void run() {
   
   
                log.debug("running...");
            }
        };

        Thread t2 = new Thread("t2") {
   
   
            @Override
            public void run() {
   
   
                while(true