Java官方文档创建线程的两种方式及优点和缺点分析

简介

根据Oracle官方文档介绍，Java提供了两种线程的创建方法，第一种是继承Thread类；第二种是实现Runable接口，并将Runnable实例传递给Thread类。Oracle官方文档介绍如下：

一. 继承Thread类，重写Run方法的方式：

优点 ： 方便传参，可以在子类添加成员变量，通过方法设置参数或构造函数传参。
缺点：
1.因为Java不支持多继承，所以继承了Thread类以后，就无法继承其他类。
2.每次都要新建一个类，不支持通过线程池操作，创建和销毁线程对资源的开销比较大。
3.从代码结构上讲，为了启动一个线程任务，都要创建一个类，耦合性太高。
4.无法获取线程任务的返回结果。

public class MyThread extends Thread {  

    public void run(){  
        //做操作
    }  
} 

启动线程：调用线程start()方法：

new MyThread().start(); 

二. 实现Runnable接口run方法，并把Runnable对象传递给Thread类的方式

优点 ： 此方式可以继承其他类。也可以使用线程池管理，节约资源。创建线程代码的耦合性较低。推荐使用此种方式创建线程。

缺点： 不方便传参，只能使用主线程中用final修饰的变量。其次是无法获取线程任务的返回结果。

分享两种写法

以下创建方程的方式都属于实现Runnable方式，只是换了个写法，同理还有通过lambda表达式等写法，就不一一列举了，万变不离其宗，只是重新包装了一下而已，并不是一种创建线程的新方式。

① 常规写法：

public class MyRunnable implements Runnable{  

    @Override  
    public void run() {  
      //做操作
    }  
} 

启动线程：依然是调用start()方法：

new Thread(new MyRunnable()).start(); 

② 匿名内部类中的写法：

优点 ： 可以在类中，任意一个方法体重使用。
缺点 ： 同上

new Thread(new Runnable() {
    @Override
    public void run() {
        //做操作    
            
    }
    }).start();

三.实现Callable方式可以获取到线程任务的返回值方式

此种方式创建线程底层源码也是使用实现Runnable接口的方式实现的，所以不是一种新的创建线程的方式，只是在实现Runnable接口方式创建线程的基础上，同时实现了Future接口，实现有返回值的创建线程。

优点 ： 可以获取线程任务执行后的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @project JavaSE
 * @description: 创建有返回值的线程
 * @author: 大脑补丁
 * @create: 2020-05-08 21:19
 */
//
public class TestCallable implements Callable<String> {

	@Override
	public String call() throws Exception {
		//自定义一个线程返回值，本例定义为String类型返回值
		return "hello world";
	}



	//测试示例：
	public static void main(String[] args) {
		//创建异步任务,参数为本例对象
		FutureTask<String> futureTask = new FutureTask<>(new TestCallable());
		// 启动线程
		new Thread(futureTask).start();

		try {
			//获取线程的返回值
			String result = futureTask.get();
			System.out.println(result);
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}

	}
}

四.如果同时使用Thread和Runnable两种方式创建线程并启动，会怎样？

public class CreateThread {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			public void run() {
				System.out.println("通过Runnable接口创建线程");
			}
		}) {
			@Override
			public void run() {
				// 此方法会覆盖掉父类run方法，即父类run方法不再执行（java面向对象中的继承特性）
				System.out.println("通过Thread类创建线程");
			}
		}.start();
	}
}

运行结果：

通过Thread类创建线程

分析：上述代码先通过Runnable方式创建一个线程，并实现接口中的run方法。然后在new Thread的方法体中再次重写Thread的run方法时，父类的run方法将不会再执行，即System.out.println("通过Runnable接口创建线程")此行代码不会被执行了，直接执行重写后的run方法System.out.println("通过Thread类创建线程")。原因是Java面向对象中继承后重写父类的方法时，该父类的方法将不再被执行，直接执行子类重写后的方法，所以结果只打印了“通过Thread类创建线程”此行输出。

五.线程的启动为什么不能直接调用run方法，而是调用start方法？

原因：
通过调用run()方法，是在主线程中执行任务，所以本质上并没有创建出新的线程。
通过调用start()方法，是在主线程中创建一个子线程去执行任务，这才是创建新线程去执行。通过start()方法启动线程后，并不一定立即执行，而是由线程调度器决定何时运行，可能立刻就会运行，也可能稍后才会运行，也可能一直不运行（饥饿状态）。

两种方式都能成功运行并执行，只是直接调用run()方法，并没有使用新线程去运行任务，程序还是串行执行的，所以这种方式是不符合预期的。

六.如果线程连续调用两次start()方法，会怎样？

示例代码：

public class ThreadClass extends Thread {

	@Override
	public void run() {
		System.out.println("运行Thread线程");
	}

	public static void main(String[] args) {
		ThreadClass threadClass = new ThreadClass();
		threadClass.start();
		threadClass.start();

	}
}

运行结果：抛出异常

Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:708)
	at thread.create.ThreadClass.main(ThreadClass.java:19)
运行Thread线程

原因分析：
查看start()方法源码：

 //Java thread status for tools,initialized to indicate thread 'not yet started'(线程状态，初始化时默认为0)
private volatile int threadStatus = 0;

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

通过源码中发现，之所以抛出java.lang.IllegalThreadStateException，是因为threadStatus不为0；threadStatus为0，表示线程刚初始化完成，还没有启动。若threadStatus不为0，说明线程已经被启动过了。所以第二次调用start()方法时，线程的状态threadStatus已改变，此时会抛出异常。

总结

根据Oracle提供的JAVA官方文档的说明，Java创建线程的方法只有两种方式，即继承Thread类和实现Runnable接口。其他所有创建线程的方式，底层都是使用这两种方式中的一种实现的，比如通过线程池、通过匿名类、通过lambda表达式、通过Callable<V>接口等等，全是通过这两种方式中的一种实现的。所以我们在掌握线程创建的时候，必须要掌握的只有这两种，通过文章中优缺点的分析，这两种方法中，最为推荐的就是实现Runnable接口的方式去创建线程。