8.启动一个线程 / 中断一个线程 / 等待一个线程

布满荆棘的人生 2022-11-03 10:38 159阅读 0赞

## 启动一个线程 ##

调用start()方法,才能正式启动一个线程

## 中断一个线程 ##

中断就是让一个线程结束，结束可能有两种情况：

**1.已经把任务执行完了**

以下代码为例：

public class ThreadDemo7 {
        
        private static boolean isQuit = false;
    
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(){
        
                @Override
                public void run() {
        
                    while (!isQuit){
        
                        System.out.println("正在转载");
                        try {
        
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    System.out.println("转载被终止");
                }
            };
            t.start();
    
            Thread.sleep(5000);
            System.out.println("需要赶快终止交易！！");
            isQuit = true;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]  
此时的结束方式是比较温和的，如果此时执行到sleep时，已经sleep了100ms了此时isQuit被设置成了true，不会立刻结束，而是把剩下的400ms执行完了在结束。

**2.任务执行了一般，被强制结束了，可以调用线程的interrupt方法来实现**

t.interrupt(); 可以给该线程触发一个异常

public class ThreadDemo8 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(){
        
                @Override
                public void run() {
        
                    //此处直接使用线程内部的标志位
                    while (!Thread.currentThread().isInterrupted()){
        
                        System.out.println("正在转载");
                        try {
        
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                            break;
                        }
                    }
                    System.out.println("终止转载");
                }
            };
            t.start();
    
            Thread.sleep(5000);
            System.out.println("赶快终止转载！！！！");
            t.interrupt();
        }
    }

1.  Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志，返回结果会改变。
2.  Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志，其中Thread.currentThread().相当于this

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]

## 等待一个线程 ##

线程之间是并发执行的，如果现在创建一个新线程，，那么这时先打印新线程还是主线程是无法预知的。，这是抢占式执行的重要特点

虽然没法控制哪个线程先跑，但是可以控制让哪个线程先结束，哪个线程后结束

join方法执行时就会造成线程阻塞，一直阻塞到对应线程执行结束之后，才会继续执行，其存在的意义就是为了控制线程结束的先后顺序

public class ThreadDemo11 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(){
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++){
        
                        System.out.println("线程一");
                    }
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            };
            Thread t2 = new Thread(){
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++){
        
                        System.out.println("线程二");
                    }
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            };
            
            t1.start();
            t1.join();//当执行这里的时候，线程就阻塞了，一直到t1结束，才会往下执行
            t2.start();
            t2.join();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221024/2010b0bf19a6437bbe70263657594c9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]: /images/20221024/38e142048111418fbf1f8d65e0577917.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 2]: /images/20221024/a8327b1cf0d24293bb14013d2719cd9c.png