一、创建和运行线程

1. 方法一，直接使用 Thread

@Slf4j(topic = "c.Test1")
public class Demo {public static void main(String[] args) {Thread t = new Thread(){@Overridepublic void run() {log.debug("running");}};t.setName("t1");t.start();}}

2. 方法二，使用 Runnable 配合 Thread

把【线程】和【任务】（要执行的代码）分开 （1）Thread 代表线程 （2）Runnable 可运行的任务（线程要执行的代码）

@Slf4j(topic = "c.Test2")
public class Test2 {public static void main(String[] args) {Runnable r = () -> log.debug("running");Thread t = new Thread(r, "t2");t.start();}
}

3. 原理之 Thread 与 Runnable 的关系

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

4. 方法三，FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

@Slf4j(topic = "c.Test1")
public class Demo {public static void main(String[] args) {FutureTask task = new FutureTask<>(new Callable() {@Overridepublic Integer call() throws Exception {log.debug("running...");Thread.sleep(2000);return 100;}});Thread t1 = new Thread(task, "t1");t1.start();}
}

二、查看进程线程的方法

1. windows

任务管理器可以查看进程和线程数，也可以用来杀死进程 （1）tasklist：查看进程

（2）taskkill：杀死进程

  

2. linux

（1）ps -fe ：查看所有进程

（2）ps -fT -p 查看某个进程（PID）的所有线程 （3）kill ：杀死进程

（4）top 按大写 H 切换是否显示线程 （5）top -H -p 查看某个进程（PID）的所有线程

3. Java

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

4. jconsole 远程监控配置

需要以如下方式运行你的 java 类

java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -
Dcom.sun.management.jmxremote.authenticate=是否认证 java类

三、常见方法

1. start 与 run

（1）直接调用 run 是在主线程中执行了 run，没有启动新的线程

（2）使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

2. sleep 与 yield

2.1 sleep

（1）调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

（2）其他线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

（3）睡眠结束后的线程未必会立刻得到执行

（4）建议用 TimeUnit 的 sleep 代替 Thread 的sleep 来获得更好的可读性

@Slf4j(topic = "c.Test8")
public class Test8 {public static void main(String[] args) throws InterruptedException {Thread.sleep(1000);TimeUnit.SECONDS.sleep(1);TimeUnit.DAYS.sleep(1);}
}

2.2 yield

（1）调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其他线程

（2）具体的实现依赖于操作系统的任务调度器

2.3 线程优先级

（1）线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它。

（2）如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲，优先级几乎没作用。

3. join 方法详解

3.1 为什么需要 join

@Slf4j(topic = "c.Test10")
public class Test10 {static int r = 0;public static void main(String[] args) throws InterruptedException {test1();}private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");r = 10;},"t1");t1.start();t1.join();log.debug("结果为:{}", r);log.debug("结束");}
}

分析 （1）因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10 （2）而主线程一开始就要打印 r 的结果，所以只能打印出 r=0 解决方法 （1）用 join，加在 t1.start() 之后即可

3.2 等待多个结果

3.3 有时效的 join 

 等待线程运行结束，最多等待 n 毫秒。

4. interrupt 方法详解

4.1 打断 sleep、wait、join 的线程

@Slf4j
public class Demo {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {log.debug("sleep...");try {Thread.sleep(5000); // wait, join} catch (InterruptedException e) {e.printStackTrace();}},"t1");t1.start();Thread.sleep(1000);log.debug("interrupt");t1.interrupt();log.debug("打断标记:{}", t1.isInterrupted());//打断标记:false}
}

4.2 打断正常运行的线程

@Slf4j
public class Demo {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while(true) {boolean interrupted = Thread.currentThread().isInterrupted();if(interrupted) {log.debug("被打断了, 退出循环");break;}}}, "t1");t1.start();Thread.sleep(1000);log.debug("interrupt");t1.interrupt();}
}

打断正常运行的线程, Thread.currentThread().isInterrupted() 会变成 true 。

4.3 模式之两阶段终止

在一个线程 T1 中如何“优雅”终止线程 T2？ 这里的【优雅】指的是给 T2 一个料理后事的机会。

错误思路：

（1）使用线程对象的 stop() 方法停止线程

        stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其他线程将永远无法获取锁。

（2）使用 System.exit(int) 方法停止线程

        目的仅是停止一个线程，但这种做法会让整个程序都停止。

 

 

@Slf4j(topic = "c.Test3")
public class Test {public static void main(String[] args) throws InterruptedException {TwoPhaseTermination tpt = new TwoPhaseTermination();tpt.start();Thread.sleep(3500);tpt.stop();}}@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{private Thread monitor;// 启动监控线程public void start(){monitor = new Thread(()->{while (true){Thread current = Thread.currentThread();if (current.isInterrupted()){log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("执行监控记录");} catch (InterruptedException e) {e.printStackTrace();// 重新设置打断标记current.interrupt();}}});monitor.start();}// 停止监控线程public void stop(){monitor.interrupt();}
}

4.4 打断 park 线程

@Slf4j(topic = "c.Test14")
public class Test14 {private static void test4() {Thread t1 = new Thread(() -> {for (int i = 0; i < 5; i++) {log.debug("park...");LockSupport.park();log.debug("打断状态：{}", Thread.interrupted());}});t1.start();sleep(1);t1.interrupt();}private static void test3() throws InterruptedException {Thread t1 = new Thread(() -> {log.debug("park...");LockSupport.park();log.debug("unpark...");log.debug("打断状态：{}", Thread.currentThread().isInterrupted());}, "t1");t1.start();sleep(1);t1.interrupt();}public static void main(String[] args) throws InterruptedException {test4();}
}

test3：如果打断标记已经是 true, 则 park 会失效

test4：可以使用 Thread.interrupted() 清除打断状态。Thread.interrupted()会重置打断标记为 false

4.5 不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

 

四、主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

@Slf4j(topic = "c.Test15")
public class Test15 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while (true) {if (Thread.currentThread().isInterrupted()) {break;}}log.debug("结束");}, "t1");t1.setDaemon(true);t1.start();Thread.sleep(1000);log.debug("结束");}
}

注意 （1）垃圾回收器线程就是一种守护线程 （2）Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

五、五种状态

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

 

六、六种状态

这是从 Java API 层面来描述的 根据 Thread.State 枚举，分为六种状态 （1）NEW 线程刚被创建，但是还没有调用 start() 方法 （2）RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的 【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行） （3）BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述 （4）TERMINATED 当线程代码运行结束