深度解析多线程的创建方式和正确启动多线程

news2024/11/25 21:42:23

一、创建多线程

1. 实现多线程

java 实现多线程的方式准确来说有两种（oracle官方文档说的）：

（1）实现 Runnable 接口，重写run()函数，运行start()方法

代码演示：

/**
 * 用Runnable方式创建线程
 */
public class RunnableStyle implements Runnable {
    @Override
    public void run() {
        System.out.println("我是一个Runnable");
    }

    public static void main(String[] args) {
        new Thread(new RunnableStyle()).start();
    }
}

（2）继承 Thread 类，重写run()函数，运行start()方法

/**
 * 用Thread方式创建线程
 * 每个线程只能操作当前线程类的对象变量，耦合性太强
 */
public class ThreadStyle extends Thread {

    @Override
    public void run() {
        System.out.println("我是一个 Thread");
    }

    public static void main(String[] args) {
        new ThreadStyle().start();
    }
}

2. 两种实现多线程方法的对比

方法1（实现Runnable接口）更好的三个优势：

（1）解耦性好，run方法业务与线程建立逻辑分离

表现1，这样创建不同的线程可以共享Runnable实例中的变量和方法，即多个线程可以操作同一资源，而Thread只能操作当前对象的业务,即每新建一个线程类，当前资源类变量都会初始化

代码实现区别

实现Runnable接口

/**
 * 用Runnable方式创建线程
 * 解耦，不同线程可以操作同一资源对象的变量，run业务与线程建立分离
 */
public class RunnableStyle implements Runnable {

    private int count = 10;

    @Override
    public void run() {
        count--;
        System.out.println(Thread.currentThread().getName() + " : count=" + count);
    }

    public static void main(String[] args) throws InterruptedException {
        RunnableStyle runnableStyle = new RunnableStyle();
        new Thread(runnableStyle,"Runnable1").start();
        Thread.sleep(1000);
        new Thread(runnableStyle, "Runnable2").start();
    }
}

Runnable1 : count=9
Runnable2 : count=8

继承Thread类

/**
 * 用Thread方式创建线程
 * 每个线程只能操共享当前线程类的对象变量，耦合性太强
 */
public class ThreadStyle extends Thread {

    private int count = 10;

    @Override
    public void run() {
        count--;
        System.out.println(Thread.currentThread().getName() + " : count=" + count);
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadStyle thread1 = new ThreadStyle();
        thread1.setName("Thread1");
        thread1.start();
        Thread.sleep(1000);
        ThreadStyle thread2 = new ThreadStyle();
        thread2.setName("Thread2");
        thread2.start();
    }
}

Thread1 : count=9
Thread2 : count=9


#### （2）节约资源，每次新建任务无需每次都新建线程，例如线程池类

使用继承Thread的方式的话，那么每次想新建一个任务，只能新建一个独立的线程，而这样做的损耗会比较大（比如重头开始创建一个线程、执行完毕以后再销毁等。如果线程的实际工作内容，也就是run()函数里只是简单的打印一行文字的话，那么可能线程的实际工作内容还不如损耗来的大）。如果使用Runnable的方式，只需要更换Runnable实例，不需要新建Thread类，就可以实现线程的重复利用，线程池就是基于这个原理，从而大大减小损耗。

#### （3）可扩展性好，可用实现多继承接口，不能实现多继承类

继承Thread类以后，由于Java语言不支持双继承，这样就无法再继承其他的类，限制了可扩展性。

### 3. 两种方法的本质对比

方法一和方法二，也就是“实现Runnable接口并传入Thread类”和“继承Thread类然后重写run()”在实现多线程的本质上，并没有区别，都是最终调用了start()方法来新建线程。这两个方法的最主要区别在于run()方法的内容来源：

```java
...
public class Thread implements Runnable {
    private Runnable target;
...
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
...
}

方法一：最终调用Runnable实例的run()方法（target.run()）;

方法二：直接将Thread类的里整个 run() 方法重写

4. 创建线程时同时使用Runnable、Thread两种方法会发生什么？

如果同时使用Runnable、Thread两种方法，那么只会执行 Thread 中重写的 run()方法，因为将父类中的run方法覆盖了：

...
public class Thread implements Runnable {
    private Runnable target;
...
    // 该 run 方法直接被重写了，便不再会执行 target.run()方法了
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
...
}

同时执行两种方式的测试：

/**
 * 同时执行两种方式的测试
 * 匿名内部类
 */
public class DoubleStyle {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("我是 Runnable");
        }) {
            @Override
            public void run() {
                System.out.println("我是 Thread");
            }
        }.start();
    }
}

执行结果：

我是 Thread 的 run方法

准确的讲，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）

5. 其它创建线程的方式

其它创建线程的方式也有很多，但都是在代码的写法上的千变万化，本质上还是都基于 Thread 类和 Runnable 类的重写run()方法。比如以下几种方式：

（1）线程池创建线程

线程池本质上，是创建有限个线程排队处理多于线程数量的业务，为了节省创建和销毁线程的时间
本质上还是实现Runnable接口创建线程类
源码片段：

（2）通过Callable和FutureTask创建线程

Callable和FutureTask类同时继承了Future接口和Runnnable接口，本质还是实现Runnnable接口中的run方法

（3）定时器也可以创建线程

演示代码：

/**
 * 描述：     定时器创建线程
 */
public class DemoTimmerTask {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }, 1000, 1000);
    }
}

其中 TimerTask 又是实现了 Runnable 接口的类。

所以，本质上，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）。

二、启动多线程

1. start()和run()对比

代码测试：

public class StartAndRunMethod {

    public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName());
        };
        runnable.run();

        new Thread(runnable).start();
    }
}

测试结果：