Java多线程 - 创建的三种方式介绍

ゞ浴缸里的玫瑰 2023-09-23 13:26 144阅读 0赞

#### 文章目录 ####

*  多线程
 *   *  多线程简介
     *  多线程创建
     *   *  方式一: 继承Thread类
         *  方式二: 实现Runnable接口
         *  方式三: 实现Callable接口

## 多线程 ##

### 多线程简介 ###

**什么是线程**?

> 线程(thread)是一个程序内部的一条执行路径。
> 
> 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
> 
>     public static void main(String[] args) {
>          
>       	// 代码...
>       	for (int i = 0; i < 10; i++) {
>          
>           	System.out.println(i);
>     		}
>       	// 代码...
>     }
> 
> 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

**什么是多线程**?

> 多线程是指从软硬件上实现多条执行流程的技术。

### 多线程创建 ###

#### 方式一: 继承Thread类 ####

**Thread类**:

> Java是通过java.lang.Thread 类来代表线程的。
> 
> 按照面向对象的思想，Thread类应该提供了实现多线程的方式。

**Thread类创建线程方式**:

> 1.  定义一个子类MyThread继承线程类java.lang.Thread
> 2.  子类MyThread中重写run()方法
> 3.  创建MyThread类的实例对象
> 4.  调用子线程对象的start()方法启动线程（启动后还是执行run方法的）

**Thread类创建多线程示例代码如下**:

public class ThreadDemo {
        
        public static void main(String[] args) {
        
            // 3. 创建MyThread类的实例对象
            Thread t = new MyThread();
            // 4. 调用子线程对象的start方法启动线程(启动后还是执行的run方法)
            t.start();
    
            // 主线程中执行的操作
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程执行输出: " + i);
            }
        }
    }
    
    /**
        1. 定义一个线程类继承自Thread
     */
    class MyThread extends Thread {
        
        /**
            2. 重写run方法, run方法中定义创建出来的线程要做什么
         */
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("子线程执行输出: " + i);
            }
        }
    }

**Thread类创建多线程的有缺点**:

> 优点：编码简单
> 
> 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展; 如果线程有执行结果是不可以直接返回的, 意思是重写的run方法如果是有返回值是没办法获取到的, 该方式只适合执行功能。

**上面提到, 调用start方法启动后还是执行的run方法, 那么为什么不直接执行run方法呢**?

> 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
> 
> 只有调用start方法才是启动一个新的线程执行。

注意: 不要把主线程执行任务的代码放在子线程之前, 因为这样做主线程一直是先跑完的才开启子线程，相当于是一个单线程的效果了。

#### 方式二: 实现Runnable接口 ####

**通过实现Runnable接口创建多线程方式如下**:

> 1.  定义一个线程任务类MyRunnable实现Runnable接口
> 2.  任务类MyRunnable中重写run()方法
> 3.  创建MyRunnable任务类对象
> 4.  把MyRunnable任务对象交给Thread处理。
> 5.  调用线程对象的start()方法启动线

**实现Runnable接口创建多线程示例代码**:

public class ThreadDemo2 {
        
        public static void main(String[] args) {
        
            // 3. 创建MyRunnable 任务对象
            Runnable target = new MyRunnable();
            // 4. 把任务对象交给线程对象(Thread)处理
            Thread t = new Thread(target);
            // 5. 启动线程
            t.start();
    
            // 主线程要执行的操作
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程执行输出: " + i);
            }
        }
    }
    
    /**
        1. 定义一个线程任务类, 实现Runnable接口
     */
    class MyRunnable implements Runnable {
        
        /**
            2. 任务类MyRunnable中重写run方法
         */
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("子线程执行输出: " + i);
            }
        }
    }

**实现Runnable接口创建多线程, 匿名内部类的方式简化方式一**:

public static void main(String[] args) {
        
        // 1. 创建任务对象(匿名内部类的方式)
        Runnable target = new Runnable() {
        
            @Override
            public void run() {
        
                for (int i = 0; i < 5; i++) {
        
                    System.out.println("子线程执行输出: " + i);
                }
            }
        };
        // 2. 将任务对象交给线程对象(Thread)处理
        Thread t = new Thread(target);
        // 3. 启动线程
        t.start();
    
        // 主线程执行的操作
        for (int i = 0; i < 5; i++) {
        
            System.out.println("主线程执行输出: " + i);
        }
    }

**实现Runnable接口创建多线程, 匿名内部类的方式简化方式二**:

public static void main(String[] args) {
        
        // 1. 创建任务对象(匿名内部类的方式)
        // 2. 将任务对象交给线程对象(Thread)处理
        // 3. 启动线程
        new Thread(new Runnable() {
        
            @Override
            public void run() {
        
                for (int i = 0; i < 5; i++) {
        
                    System.out.println("子线程执行输出: " + i);
                }
            }
        }).start();
    
        // 主线程执行的操作
        for (int i = 0; i < 5; i++) {
        
            System.out.println("主线程执行输出: " + i);
        }
    }

**实现Runnable接口创建多线程, 匿名内部类结合Lambda表达式的方式简化方式三**:

public static void main(String[] args) {
        
        // 1. 创建任务对象(匿名内部类的方式)
        // 2. 将任务对象交给线程对象(Thread)处理
        // 3. 启动线程
        new Thread(() -> {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("子线程执行输出: " + i);
            }
        }).start();
    
        // 主线程执行的操作
        for (int i = 0; i < 5; i++) {
        
            System.out.println("主线程执行输出: " + i);
        }
    }

**实现Runnable接口创建多线程的优缺点**:

> 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
> 
> 缺点：编程多一层对象包装，如果线程有执行结果是拿不到返回结果的。

#### 方式三: 实现Callable接口 ####

**前两种线程创建方式都存在一个问题**:

> 他们重写的run方法均不能直接返回结果。
> 
> 不适合需要返回线程执行结果的业务场景。

**那么如何解决这个问题呢**?

> JDK 5.0提供了Callable和FutureTask结合使用来实现多线程。
> 
> 这种实现多线程方式的优点是：可以得到线程执行的结果。

**多线程的实现方案三：利用Callable、FutureTask接口实现, 实现步骤如下**:

> ① 得到任务对象
> 
>  *  定义类实现Callable接口，重写call方法，call方法中封装我们要做的事情, 并且call方法是可以返回结果的。
>  *  把Callable任务对象交给FutureTask封装成线程任务对象。
> 
> ② 把线程任务对象交给线程对象(Thread)处理。
> 
> ③ 调用Thread的start方法启动线程，执行任务
> 
> ④ 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

**使用FutureTask包装的作用**:

> 作用一: Thread线程对象构造器只接受Runnable类型的对象, FutureTask是实现了Runnable接口的, 可以交给Thread处理
> 
> 作用二: 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果

**FutureTask的API**

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>FutureTask&lt;&gt;(Callable call)</td> 
   <td>把Callable对象封装成FutureTask对象。</td> 
  </tr> 
  <tr> 
   <td>get() throws Exception</td> 
   <td>获取线程执行call方法返回的结果。</td> 
  </tr> 
 </tbody> 
</table>

**演示代码**

public class ThreadDemo4 {
        
        public static void main(String[] args) {
        
            // 3. 创建任务对象
            Callable<String> callable  = new MyCallable(5);
    
            // 4. 将任务对象包装成线程任务对象
            FutureTask<String> ft = new FutureTask<>(callable);
    
            // 5. 将线程任务对象交给线程对象(Thread)处理
            Thread t = new Thread(ft);
    
            // 6. 启动线程
            t.start();
    
            // 获取线程执行的结果, 会返回正常的结果和异常的结果
            try {
        
                String res = ft.get();
                System.out.println(res);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }
    
    /**
        1. 定义类实现Callable接口
        泛型自定义返回值类型
     */
    class MyCallable implements Callable<String> {
        
        private int n;
        public MyCallable(int n) {
        
            this.n = n;
        }
        /**
            2. 重新实现类call方法(任务方法)
         */
        @Override
        public String call() throws Exception {
        
            int sum = 0;
            for (int i = 1; i <= n ; i++) {
        
                sum += i;
            }
            return "子线程方法执行的结果是" + sum;
        }
    }

**方式三的优缺点**:

> 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
> 
> 可以在线程执行完毕后去获取线程执行的结果。
> 
> 缺点：编码会显得复杂一点。

**总结: 三种方式对比如下**

<table> 
 <thead> 
  <tr> 
   <th>方式</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>继承Thread类</td> 
   <td>编程比较简单，可以直接使用Thread类中的方法</td> 
   <td>扩展性较差，不能再继承其他的类，不能返回线程执行的结果</td> 
  </tr> 
  <tr> 
   <td>实现Runnable接口</td> 
   <td>扩展性强，实现该接口的同时还可以继承其他的类。</td> 
   <td>编程相对复杂，不能返回线程执行的结果</td> 
  </tr> 
  <tr> 
   <td>实现Callable接口</td> 
   <td>扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果</td> 
   <td>编程相对复杂</td> 
  </tr> 
 </tbody> 
</table>