JUC并发编程(3.Java线程）

柔情只为你懂 2023-09-23 22:51 32阅读 0赞

> [继上篇文章未完全介绍完join方法  
> ][join_]

# 1.Join方法 #

## 1.1 有时效的join ##

> 等够时间

public class Test10 {
        
        static int r1 = 0;
        static int r2 = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            test2();
        }
    
        private static void test2() throws InterruptedException {
        
            Thread t1 = new Thread(() -> {
        
                sleep(1);
                r1 = 10;
            });
            Thread t2 = new Thread(() -> {
        
                sleep(2);
                r2 = 20;
            });
            long start = System.currentTimeMillis();
            t1.start();
            t1.join(1500);
    
            long end = System.currentTimeMillis();
            log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
        }
    }

08:38:09.478 c.Test10 [main] - r1: 10 r2: 0 cost: 1003

> 没等够使时间

public class Test10 {
        
        static int r1 = 0;
        static int r2 = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            test2();
        }
    
        private static void test2() throws InterruptedException {
        
            Thread t1 = new Thread(() -> {
        
                sleep(2);
                r1 = 10;
            });
            Thread t2 = new Thread(() -> {
        
                sleep(2);
                r2 = 20;
            });
            long start = System.currentTimeMillis();
            t1.start();
            t1.join(1500);
    
            long end = System.currentTimeMillis();
            log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
        }
    }

08:39:45.580 c.Test10 [main] - r1: 0 r2: 0 cost: 1509

# 2.interrupt 方法详解 #

## 2.1 打断 sleep，wait，join 的线程 ##

> 打断 sleep 的线程, 会清空打断状态

public class Test10 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(()->{
        
                sleep(1);
            }, "t1");
            t1.start();
            sleep(0.5);
            t1.interrupt();
            log.debug(" 打断状态: {}", t1.isInterrupted());
        }
    }

java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at java.lang.Thread.sleep(Thread.java:340)
    	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    	at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
    	at cn.itcast.test.Test10.lambda$main$0(Test10.java:11)
    	at java.lang.Thread.run(Thread.java:748)
    08:43:54.097 c.Test10 [main] -  打断状态: false

## 2.2打断正常运行的线程 ##

> 打断正常运行的线程  
> 打断正常运行的线程, 不会清空打断状态

public class Test10 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t2 = new Thread(() -> {
        
                while (true) {
        
                    Thread current = Thread.currentThread();
                    boolean interrupted = current.isInterrupted();
                    if (interrupted) {
        
                        log.debug(" 打断状态: {}", interrupted);
                        break;
                    }
                }
            }, "t2");
            t2.start();
            sleep(0.5);
            t2.interrupt();
        }
    }

10:48:34.396 c.Test10 [t2] -  打断状态: true

## 2.3 打断 park 线程 ##

> 打断 park 线程, 不会清空打断状态

public class Test10 {
        
        public static void main(String[] args) throws InterruptedException {
        
                Thread t1 = new Thread(() -> {
        
                    log.debug("park...");
                    LockSupport.park();
                    log.debug("unpark...");
                    log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
                }, "t1");
                t1.start();
                sleep(0.5);
                t1.interrupt();
    
        }
    }

10:51:13.876 c.Test10 [t1] - park...
    10:51:14.391 c.Test10 [t1] - unpark...
    10:51:14.391 c.Test10 [t1] - 打断状态：true

> 如果打断标记已经是 true, 则 park 会失效
> 
> > 可以使用 Thread.interrupted() 清除打断状态

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

10:52:32.481 c.Test10 [Thread-0] - park...
    10:52:33.495 c.Test10 [Thread-0] - 打断状态：true
    10:52:33.497 c.Test10 [Thread-0] - park...
    10:52:33.497 c.Test10 [Thread-0] - 打断状态：true
    10:52:33.497 c.Test10 [Thread-0] - park...
    10:52:33.497 c.Test10 [Thread-0] - 打断状态：true
    10:52:33.497 c.Test10 [Thread-0] - park...
    10:52:33.497 c.Test10 [Thread-0] - 打断状态：true
    10:52:33.497 c.Test10 [Thread-0] - park...
    10:52:33.497 c.Test10 [Thread-0] - 打断状态：true

# 3.不推荐的方法 #

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

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>stop()</td> 
   <td>停止线程运行</td> 
  </tr> 
  <tr> 
   <td>suspend()</td> 
   <td>挂起（暂停）线程运行</td> 
  </tr> 
  <tr> 
   <td>resume()</td> 
   <td>恢复线程运行</td> 
  </tr> 
 </tbody> 
</table>

# 4.主线程与守护线程 #

> 默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做**守护线程**，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。  
> 垃圾回收器线程就是一种守护线程,Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

public class Test10 {
        
        public static void main(String[] args) throws InterruptedException {
        
            log.debug("开始运行...");
            Thread t1 = new Thread(() -> {
        
                log.debug("开始运行...");
                sleep(2);
                log.debug("运行结束...");
            }, "daemon");
            // 设置该线程为守护线程
            t1.setDaemon(true);
            t1.start();
            sleep(1);
            log.debug("运行结束...");
        }
    }

10:57:53.258 c.Test10 [main] - 开始运行...
    10:57:53.284 c.Test10 [daemon] - 开始运行...
    10:57:54.300 c.Test10 [main] - 运行结束...

# 5.5种状态 #

> **操作系统层面**来描述的5种状态

![在这里插入图片描述][594758ee50474c968b72136a6ddf8300.png]

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

# 6. 6种状态 #

> 从 **Java API 层面**来描述的,根据 Thread.State 枚举，分为六种状态

![在这里插入图片描述][050372df84fb4f32a1b1a2df388f28e7.png]

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

# 7.总结 #

*  线程创建
 *  线程重要 API，如 start，run，sleep，join，interrupt 等
 *  线程状态
 *  应用方面
    
     *  异步调用：主线程执行期间，其它线程异步执行耗时操作
     *  提高效率：并行计算，缩短运算时间
     *  同步等待：join
     *  统筹规划：合理使用线程，得到最优效果
 *  原理方面
    
     *  线程运行流程：栈、栈帧、上下文切换、程序计数器
     *  Thread 两种创建方式 的源码
 *  模式方面
    
     *  终止模式之两阶段终止

[join_]: https://blog.csdn.net/weixin_45428910/article/details/128759241
[594758ee50474c968b72136a6ddf8300.png]: https://img-blog.csdnimg.cn/594758ee50474c968b72136a6ddf8300.png
[050372df84fb4f32a1b1a2df388f28e7.png]: https://img-blog.csdnimg.cn/050372df84fb4f32a1b1a2df388f28e7.png