Java基础之创建线程本质方法, 线程的状态, 如何终止线程

港控/mmm° 2023-06-23 04:57 4阅读 0赞

# 1. 创建线程本质方法 #

## 1.1 两种方法 ##

*  继承Thread类，重写run方法。**用start()方法启动线程**
 *  实现Runnable接口，实现run方法,`new Thread(Runnable r).start()`启动线程.

**实际上所有的多线程代码都是通过运行Thread的start()方法来运行的**。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。  
**run()是线程的方法本体.**  
**Runnable对象仅仅作为Thread对象的target**，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法

## 1.2 Thread和Runnable的区别 ##

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1.  适合多个相同的程序代码的线程去共享同一个资源。
2.  可以避免java中的单继承的局限性。
3.  增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.  线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

## 1.3 Thread的run()方法和start()方法的区别 ##

**java的线程**是通过java.lang.Thread类来实现的。JVM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，**方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程**。

## 1.4 多线程(并发)原理 ##

相当于随机演讲,只有一个讲台(cpu),但是班里有很多人.怎么办?随机排队,讲台上有个指针,随机指定.指定谁就是谁来.  
**start是排队,等cpu选中你就是轮到你,你就run()**,当cpu的运行的时间片执行完,这个线程就继续排队,等待下一次的run()。

**调用start后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态**。

然后通过JVM，**线程Thread会调用run方法，执行本线程的线程体**。先调用start后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。

1.**start()方法来启动线程，真正实现了多线程运行**。这时无需等待run方法体代码执行完毕，可以直接继续执行如下操作:通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。  
2.**run()方法当作普通方法的方式调用**。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。  
**记住：多线程就是分时利用CPU，宏观上让所有线程在同一时间段内执行 ，即并发.**

# 2. 线程的状态及如何退出线程 #

## 2.1 java中线程的状态 ##

在Java当中，**线程通常都有5种状态**，新建状态、就绪状态、运行状态、阻塞状态和死亡状态。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ_size_16_color_FFFFFF_t_70]

1.  第一是**新建状态**。在生成线程对象，**并没有调用该对象的start方法**，这是线程处于创建状态。
2.  第二是**就绪状态**。当**调用了线程对象的start方法**之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。
3.  第三是**运行状态**。线程调度程序将处于就绪状态的线程**设置为当前线程**，此时线程就进入了运行状态，**开始运行run函数当中的代码**。
4.  第四是**阻塞状态**。阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：  
    (1)等待 – 通过调用线程的**wait()** 方法，让线程等待某工作的完成。  
    (2)超时等待 – 通过调用线程的**sleep()** 或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。  
    (3)同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
5.  第五是**死亡状态**: 线程执行完了或者因异常退出了run()方法，该线程结束生命周期.

## 2.2 Java中wait和sleep的区别 ##

### 2.2.1 线程等待wait ###

调用该方法的线程进入**Waiting**状态，只有等待另外线程的通知或被中断才会返回，需要注意的是调用wait()方法后，**会释放对象的锁**。因此，wait方法一般用在同步方法或同步代码块中。

### 2.2.2 线程睡眠sleep ###

sleep导致当前线程休眠，与wait方法不同的是**sleep不会释放当前占有的锁**，sleep(long)会导致线程进入**Timed-Waiting**状态,而**wait()方法会导致当前线程进入Waiting状态.**

### 2.2.3 区别 ###

最大的不同是,等待wait时会释放锁,而sleep一直持有锁.wait通常被用于线程间交互,sleep通常被用于暂停执行.

## 2.3 如何终止线程 ##

如上提到了创建线程的本质方法, 及线程创建后的5种状态, 那么如何终止一个线程呢?  
Java中的Thread类虽然有stop()方法可以中断一个线程,但是由于可能会导致资源无法正常释放等问题, 已经被废弃, 所以需要另寻他法.

### 2.3.1 第一种:结合实际开发业务, 打标志 ###

中断线程最好的方式就是结合线程的业务逻辑, 通过设置标记位, 让线程任务提前结束.

1.   //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
    2.    public volatile boolean exit = false; 
    3.    @Override
    4.    public void run() { 
    5.               while(!exit){ 
    6.                ...//业务逻辑
    7.        }
    8.    }
     
     // 如下开启此线程, 并给exit赋值操作, 当!exit=true, 退出run()方法, 线程终止.

### 2.3.2 使用Thread类的interrupt()方法 ###

*  用 **interrupt()** 方法仅仅是在当前线程中打一个停止的标记, 线程并不会立即终止线程. 而是通知目标线程, 有人希望你终止.
 *  至于线程收到通知后会如何处理, 则**完全由线程自行决定**.

1.public static void main(String[] args) throws InterruptedException { 
    	      //1. 创建线程
    3.        Thread thread = new Thread(new Runnable() { 
    4.            @Override
    5.            public void run() { 
    6.                long startTime = System.currentTimeMillis();
    7.                for (int i=0;i<1000000;i++){ 
    8.                    System.out.println("任务正在执行中："+i);
    9.                }
    10.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
    11.            }
    12.        });
    13.        //2.启动线程
    14.        thread.start();
    15.        //让主线程, 也就是main方法睡眠2000毫秒，然后中断该子线程
    16.        Thread.sleep(2000);
    17.        
    18. 		//3.给线程打标记终止线程
    19.        thread.interrupt();
    20.    }

![在这里插入图片描述][20210103163055905.png]  
但是通过运行结果, 发现子线程并未被终止.

### 2.3.3 使用isInterrupted()终止线程 ###

如果想终止任务, 还需要结合使用Thread.isInterrupted()方法：

1.public static void main(String[] args) throws InterruptedException { 
    	      //1. 创建线程
    3.        Thread thread = new Thread(new Runnable() { 
    4.            @Override
    5.            public void run() { 
    6.                long startTime = System.currentTimeMillis();
    7.                for (int i=0;i<1000000;i++){ 
    8.                    //判断当前线程的状态是否已经标记为终止, 此Thread指的是子线程.
    9.                    if (Thread.interrupted()){ 
    10.                        //如果线程已经标记为终止则跳出循环（其实就是结束任务了）
    11.                       break;
    12.                    }
    13.                    System.out.println("任务正在执行中："+i);
    14.                }
    15.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
    16.            }
    17.        });
    18. 
    19.        //2.启动子线程
    20.        thread.start();
    21.        //让主线程也就是main方法睡眠2000毫秒，然后中断子该线程
    22.        Thread.sleep(2000);
    24. 		//3.给子线程打标记终止线程
    25.        thread.interrupt();
    26.    }

在上面这段代码中, 我们增加了 Thread.isInterrupted() 来判断当前线程是否被中断了, 如果是, 则退出 for 循环, 结束线程.  
![在这里插入图片描述][20210103164500228.png]  
线程被成功终止了.

### 备注: 如果线程处于sleep()或者wait()状态, 如何终止此线程 ###

使用try…catch…, 在catch中跳出循环或者终止线程.

1.public static void main(String[] args) throws InterruptedException { 
    	      //1. 创建线程
    3.        Thread thread = new Thread(new Runnable() { 
    4.            @Override
    5.            public void run() { 
    6.                long startTime = System.currentTimeMillis();
    7.                for (int i=0;i<1000000;i++){ 
    8.                    //判断当前线程的状态是否已经标记为终止, 此Thread指的是子线程.
    9.                    if (Thread.interrupted()){ 
    10.                        //如果线程已经标记为终止则跳出循环（其实就是结束任务了）
    11.                       break;
    12.                    }
    11.                    try { 
    12.                        //如果此子线程正在睡眠状态，被终止时被抛出InterruptedException异常，并且会清除interrupt终止位
    13.                        Thread.sleep(10);
    14.                        System.out.println("任务正在执行中："+i);
    15.                    } catch (InterruptedException e) { 
    16.                        e.printStackTrace();
    17.                        //当线程被终止时会遇到异常，在异常中终止线程
    18.                        break;
    19.                    }
    14.                }
    15.                System.out.println("任务执行完毕，耗时："+(System.currentTimeMillis() - startTime));
    16.            }
    17.        });
    18. 
    19.        //2.启动子线程
    20.        thread.start();
    21.        //让主线程也就是main方法睡眠2000毫秒，然后中断子该线程
    22.        Thread.sleep(2000);
    24. 		//3.给子线程打标记终止线程
    25.        thread.interrupt();
    26.    }

结果如下  
![在这里插入图片描述][2021010316564443.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210103160757471.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTkwOQ==,size_16,color_FFFFFF,t_70
[20210103163055905.png]: https://img-blog.csdnimg.cn/20210103163055905.png
[20210103164500228.png]: https://img-blog.csdnimg.cn/20210103164500228.png
[2021010316564443.png]: https://img-blog.csdnimg.cn/2021010316564443.png