【多线程】线程的三种常见创建方式

线程创建方式1——Thread

Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下

1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）

public class MyThread extends Thread{// 2、必须重写Thread类的run方法@Overridepublic void run() {// 描述线程的执行任务。for (int i = 1; i <= 5; i++) {System.out.println("子线程MyThread输出：" + i);}}
}

再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程

public class ThreadTest1 {// main方法是由一条默认的主线程负责执行。public static void main(String[] args) {// 3、创建MyThread线程类的对象代表一个线程Thread t = new MyThread();// 4、启动线程（自动执行run方法的）t.start(); for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出：" + i);}}
}

打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）

最后我们还需要注意一点：不能直接去调用run方法，如果直接调用run方法就不认为是一条线程启动了，而是把Thread当做一个普通对象，此时run方法中的执行的代码会成为主线程的一部分。此时执行结果是这样的。

线程创建方式2——Runnable

Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下

1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）

代码如下：先准备一个Runnable接口的实现类

/*** 1、定义一个任务类，实现Runnable接口*/
public class MyRunnable implements Runnable{// 2、重写runnable的run方法@Overridepublic void run() {// 线程要执行的任务。for (int i = 1; i <= 5; i++) {System.out.println("子线程输出 ===》" + i);}}
}

再写一个测试类，在测试类中创建线程对象，并执行线程

public class ThreadTest2 {public static void main(String[] args) {// 3、创建任务对象。Runnable target = new MyRunnable();// 4、把任务对象交给一个线程对象处理。//  public Thread(Runnable target)new Thread(target).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出 ===》" + i);}}
}

运行上面代码，结果如下图所示**（注意：没有出现下面交替执行的效果，也是正常的）**

线程创建方式2——匿名内部类

这种写法不是新知识，只是换一种写法。刚刚我们的第二种线程的创建方式，需要写一个Runnable接口的实现类，然后再把Runnable实现类的对象传递给Thread对象。

现在如果不想写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象。

代码如下

public class ThreadTest2_2 {public static void main(String[] args) {// 1、直接创建Runnable接口的匿名内部类形式（任务对象）Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程1输出：" + i);}}};new Thread(target).start();// 简化形式1：new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程2输出：" + i);}}}).start();// 简化形式2：new Thread(() -> {for (int i = 1; i <= 5; i++) {System.out.println("子线程3输出：" + i);}}).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出：" + i);}}
}

线程创建方式3——Callable、FutureTask,带返回值

已经有两种了为什么还有要第三种呢？ 这样，我们先分析一下前面两种都存在的一个问题。然后再引出第三种可以解决这个问题。

• 假设线程执行完毕之后有一些数据需要返回，前面两种方式重写的run方法均没有返回结果。

  public void run(){...线程执行的代码...
  }
  

• JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。

  在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的

第三种创建线程的方式，步骤如下

1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)
等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中
6.调用FutrueTask对的get()方法获取返回结果

代码如下：先准备一个Callable接口的实现类

class MyCallable implements Callable<Integer >{public int target;public MyCallable(int s){target =s;}@Overridepublic Integer call() throws Exception {int sum=0;for(int i=0;i<=target;i++){sum+=i;}return sum;}
}

再定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果。

public class test_thread2 {public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Integer>call=new MyCallable(100);FutureTask<Integer>f1=new FutureTask<>(call);new Thread(f1).start();Callable<Integer>call1=new MyCallable(200);FutureTask<Integer>f2=new FutureTask<>(call1);new Thread(f2).start();int res1 = f1.get();System.out.println(res1);int res2=f2.get();System.out.println(res2);}
}