多线程的实现方式

（一）第一种方式：继承方式

1 、在 JDK 中有一个类是线程类： Thread

2 、操作步骤

（1）自定义一个类型继承 Thread 类

（2）在自定义类型中重写 Thread 类中的 run 方法，方法体就是将来线程的任务

（3）创建自定义类型对象，表示一个线程

（4）调用 start 方法，启动线程

public static void main(String[] args) {
//（3）创建自定义类型对象，表示一个线程
MyThread mt = new MyThread();
//（4）调用start方法，启动线程
mt.start();
for (int i = 0; i < 1000; i++) {
System.out.println(i +"main---");
}
}
}
//（1）自定义一个类型继承Thread类
class MyThread extends Thread {
//（2）在自定义类型中重写Thread类中的run方法，方法体就是将来线程的任务
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(i +"MyThread===================");
}
}

（二）第二种方式：实现方式

1 、在 JDK 中有一个接口： Runnable

2 、步骤：

（1）自定义一个类，实现 Runnable 接口

（2）在自定义类中重写 Runnable 接口的 run 方法

（3）创建自定义类型的对象，表示一个任务

（4）创建线程对象，将任务添加到线程中

（5）线程对象调用 start 方法，启动线程

public static void main(String[] args) {
//（3）创建自定义类型的对象，表示一个任务
MyTask mt = new MyTask();
//（4）创建线程对象，将任务添加到线程中
Thread t = new Thread(mt);
//（5）线程对象调用start方法，启动线程
t.start();
for (int i = 0; i < 1000; i++) {
System.out.println(i + "main-");
}
}
//（1）自定义一个类，实现Runnable接口
class MyTask implements Runnable {
//（2）在自定义类中重写Runnable接口的run方法
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(i + "Runnable-----------------");
}
}
}

（三）匿名内部类简化多线程

public static void main(String[] args) {
//第一种方式：继承
new Thread() {
@Override
public void run() {
System.out.println("继承方式中的执行了");
}
}.start();
//继承第二种写法
Thread t = new Thread() {
@Override
public void run() {
System.out.println("继承方式2执行了");
}
};
t.start();
//第二种方式：实现
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("接口中的方法执行了");
}
};
Thread th = new Thread(r);
th.start();
//实现第二种写法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("接口中的方法2执行了");
}
}).start();
}

（四）两种方式比较

1 、代码复杂程度

（1）继承方式比较简单

（2）实现方式比较复杂

2 、实现原理

（1）继承方式：创建好线程之后，调用 start 方法， start 方法又调用了 start0 方法， start0 方法又调用了

run 方法，因为在自定义类型中重写了 Thread 父类中的 run 方法，根据重写的原则，直接执行子类的逻

辑，我们重写的线程逻辑就执行了

（2）实现方式：创建接口的实现类对象，这个对象是一个任务对象。创建线程对象，将任务添加到线程

对象中，将任务对象作为参数列表进行传递，线程对象在创建的过程中，连续调用了两个 init 方法，之后，将任务对象作为线程对象的成员变量，赋值给线程。调用start 方法启动线程， start 方法又调用了start0方法， start0 方法又调用了 Thread 中的 run 方法，此时这个 run 方法执行，因为没有任何类型继承线程类，没有重写run 方法；先判断接口的声明引用是否赋值成功，如果成功接口的声明引用调用接口中的run 方法，因为接口中的 run 方法是抽象的，我们定义了自定义类型实现接口，并实现接口中的 run方法，此时执行的就是接口实现类中的run 方法，我们的业务逻辑就得到了实现。

3 、设计

（1）继承方式：自定义类型继承 Thread 类型，就无法再去继承其它类型，代码扩展性较差

（2）实现方式：一个类在实现多个接口的同时还可以继承一个类型，代码扩展性较强

4 、灵活性

（1）继承方式：将业务逻辑和线程对象绑定在一起了，耦合度高，灵活性差

（2）实现方式： 将任务和线程对象分开设计，降低耦合度，灵活性较强，一个任务对象可以被多个线程执行，一个线程也可以执行不同的任务对象，并且将来可以将任务对象，提交到线程池中，任务对象被不同的线程执行，也方便多线程之间的数据交互.