Thread类的基本用法

妖狐艹你老母 2024-04-23 20:32 72阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> ? 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> ? 收录专栏：[JavaEE][]  
> ? 持续更文，关注博主少走弯路，谢谢大家支持 ?

#### Thread ####

*  1. 线程创建
 *   *  1.1 继承Thread类
     *  1.2 实现Runnable接口
     *  1.3 使用匿名内部类创建Thread子类对象
     *  1.4 使用匿名类创建 Runnable 子类对象
     *  1.5 使用lambda 表达式
 *  2. 线程中断
 *   *  2.1 使用自定义的变量来作为标记位
     *  2.2 调用interrupt()方法来通知
 *  3. 线程等待-join()
 *  4. 线程休眠-sleep()
 *  5. 获取线程实例

![在这里插入图片描述][3a293f10c82f4244a62c9a07b83649e9.gif_pic_center]

## 1. 线程创建 ##

### 1.1 继承Thread类 ###

class MyThread extends Thread{
        
        public void run(){
        
            System.out.println("继承Thread,重写run");
        }
    }
    public class TestDemo1{
        
        public static void main(String[] args) {
        
            MyThread thread = new MyThread();
            thread.start();//启动线程
        }
    }

### 1.2 实现Runnable接口 ###

class MyRunnable implements Runnable{
        
        public void run(){
        
            System.out.println("实现Runnable接口");
        }
    }
    public class TestDemo1{
        
        public static void main(String[] args) {
        
            Thread thread=new Thread(new MyRunnable());
            thread.start();
        }
    }

### 1.3 使用匿名内部类创建Thread子类对象 ###

public class TestDemo1{
        
        public static void main(String[] args) {
        
            Thread thread=new Thread(){
        
                public void run(){
        
                    System.out.println("这是一个线程");
                }
            };
            thread.start();
        }
    }

### 1.4 使用匿名类创建 Runnable 子类对象 ###

public class TestDemo1{
        
        public static void main(String[] args) {
        
            Thread thread=new Thread(new Runnable(){
        
                public void run() {
        
                    System.out.println("实现Runnable，重写run，使用匿名内部类");
                }
            });
            thread.start();//启动线程
        }
    }

### 1.5 使用lambda 表达式 ###

public class TestDemo1{
        
        public static void main(String[] args) {
        
            Thread thread=new Thread(()->{
        
                    System.out.println("使用lambda表达式");
            });
            thread.start();
        }
    }

## 2. 线程中断 ##

当我们想要让一个正在执行的线程停止时，该怎么做呢？

### 2.1 使用自定义的变量来作为标记位 ###

ublic class TestDemo2 {
        
        private static volatile boolean isquit=false;
        public static void main(String[] args) {
        
            Thread thread=new Thread(()->{
        
                while(!isquit){
        
                    System.out.print(Thread.currentThread().getName());
                    System.out.println("线程工作中...");
                }
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                //线程运行完毕
                System.out.println("线程工作完毕");
            });
            thread.start();
            try {
        
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            isquit = true;
            System.out.println("让 thread 线程结束!");
        }
    }

需要给标志位上加 volatile 关键字才能进行修改

### 2.2 调用interrupt()方法来通知 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void interrupt()</td> 
   <td>中断对象关联的线程</td> 
  </tr> 
  <tr> 
   <td>public static boolean interrupted()</td> 
   <td>判断当前线程的中断标志位是否设置</td> 
  </tr> 
  <tr> 
   <td>public bool isInterrupted()</td> 
   <td>判断对象关联的线程标志位是否设置</td> 
  </tr> 
 </tbody> 
</table>

public class TestDemo2 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread=new Thread(()-> {
        
                //while(!Thread.interrupted()){
        
                while (!Thread.currentThread().isInterrupted()) {
        
                    System.out.println("线程工作中...");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        break;
                    }
                }
            });
            thread.start();
            Thread.sleep(2000);
            // 使用一个 interrupt 方法, 来修改刚才标志位的值
            System.out.println("让 thread 线程结束");
            thread.interrupt();
        }
    }

thread 收到通知的⽅式有两种：

1.  如果线程因为调⽤ wait/join/sleep 等⽅法⽽阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志。  
    当出现 InterruptedException 的时候，要不要结束线程取决于catch 中代码的写法。可以选择忽略这个异常，也可以跳出循环结束线程。
2.  否则，只是内部的⼀个中断标志被设置，thread 可以通过。  
    Thread.currentThread().isInterrupted()判断指定线程的中断标志被设置，不清除中断标志，这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

## 3. 线程等待-join() ##

有时，我们需要等待⼀个线程完成它的⼯作后，才能进⾏⾃⼰的下⼀步⼯作。

public class TestDemo3{
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                int n = 5;
                for (int i = 0; i < n; i++) {
        
                    System.out.println("我是一个线程, 正在工作中...");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                System.out.println("线程执行结束");
            });
    
            t.start();
            t.join();  // 线程等待
            System.out.println("这是主线程, 期望在 thread 结束后打印");
        }
    }

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

如果将`t.join()`注释，结果会是什么呢？  
![在这里插入图片描述][4b35c67a7b884c6f91ac105579512357.png]

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void join()</td> 
   <td>等待线程结束</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis)</td> 
   <td>等待线程结束，最多等待millis毫秒</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis,int nanos)</td> 
   <td>同上</td> 
  </tr> 
 </tbody> 
</table>

## 4. 线程休眠-sleep() ##

为线程的调度是不可控的，所以，该⽅法只能保证实际休眠时间是⼤于等于参数设置的休眠时间的。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sleep(long millis) throws InterruptedException</td> 
   <td>休眠当前线程run方法</td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long millis,int nanos) throws InterruptedException</td> 
   <td>可以更高精度的休眠线程</td> 
  </tr> 
 </tbody> 
</table>

public class TestDemo4 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1=new Thread(()->{
        
                System.out.println("t1正在执行");
            });
            Thread t2=new Thread(()->{
        
                System.out.println("t2正在执行");
            });
            t1.start();
            t2.start();
        }
    }

上面的执行过程中，我们无法控制t1与t2的先后执行顺序，运行时就会产生：  
![在这里插入图片描述][9996e89a92f742438b29bef2fc414145.png]

但是当我们让main线程在执行t1线程时，进入有限的休眠状态，就可以保证t2不会来干扰t1

![在这里插入图片描述][9cc6f9b40ad24bf4a9113c9351f9a3d2.png]

## 5. 获取线程实例 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static Thread currentThread();</td> 
   <td>返回当前线程对象的引用</td> 
  </tr> 
 </tbody> 
</table>

public class TestDemo5 {
        
        public static void main(String[] args) {
        
            Thread thread=Thread.currentThread();
            System.out.println(thread.getId());//1
            System.out.println(thread.getName());//main
        }
    }

public class TestDemo5 {
        
        public static void main(String[] args) {
        
           // Thread thread=Thread.currentThread();
            Thread thread=new Thread();
            System.out.println(thread.currentThread().getId());//1
            System.out.println(thread.getName());//Thread-0
        }
    }

[Link 1]: https://blog.csdn.net/iLoyo_
[JavaEE]: http://t.csdnimg.cn/p0IQF
[3a293f10c82f4244a62c9a07b83649e9.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/672041cedc56453f8ef5d0d44f4f4ccc.gif
[dade385afa8c4e2881908ac532af1234.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/96454b5b766d4f518d4dd5aeae78953f.png
[4b35c67a7b884c6f91ac105579512357.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/fd3e00b83804446db09da35f7d050bfb.png
[9996e89a92f742438b29bef2fc414145.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/32a8b39840374b72b40d2cad6db53eea.png
[9cc6f9b40ad24bf4a9113c9351f9a3d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a93f10d715a642fdaae0949148825e00.png