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

本文介绍了Java中创建线程的两种基本方法:继承Thread类和实现Runnable接口。详细对比了这两种方法的优缺点,并介绍了如何使用Callable接口来获取线程执行结果。
简介

根据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的方法体中再次重写Threadrun方法时,父类的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接口的方式去创建线程。

<think>好的,我现在需要帮助用户理解Java创建线程两种方式及其优缺点。用户之前已经问过关于Java关键字的问题,现在转向线程创建。根据提供的引用内容,用户可能已经知道有两种基本方法:继承Thread类实现Runnable接口,但需要更详细的对比。首先,我需要确认用户提供的引用内容。引用[1]明确指出Java官方文档只支持两种方式,其他如线程池、Callable等都是基于这两种实现的。引用[2]提到四种方式,但实际还是两种核心方法,另外两种可能是指Callable线程池,但用户的问题集中在两种官方方法,所以需要明确区分。引用[3][4]详细说明了实现Runnable的优点,比如多实现、灵活性,以及缺点如稍微复杂。接下来,我需要整理这两种方式的步骤、优缺点。对于继承Thread类,步骤是继承并重写run方法,然后实例化并调用start。优点是简单直接,缺点是无法继承其他类,灵活性差。而实现Runnable接口则需要创建实现类,将实例传递给Thread对象,优点是可以多实现,资源共享,适合多线程处理同一资源,但步骤稍繁琐。 用户可能存在的疑问是为什么推荐Runnable,这里需要结合单继承限制资源共享的优势来解释。同时,需要提到Thread类本身实现了Runnable接口,这点在引用[2]中有提到,可以加强说明。 另外,关于线程池或其他方式,虽然用户问题集中在两种方法,但可以简要提及它们底层还是基于这两种,避免用户混淆。例如,CallableFutureTask其实属于实现Runnable的扩展。最后,生成相关问题时要围绕线程创建的其他方式、选择依据、资源共享机制等,帮助用户深入理解。确保引用标记正确,比如在提到资源共享时引用[2][3],在提到官方文档时引用[1]。</think>### Java创建线程两种方法及其优缺点对比 #### 一、继承`Thread`类 1. **实现步骤** - 定义子类继承`Thread` - 重写`run()`方法定义线程任务 - 创建子类实例并调用`start()`启动线程 ```java class MyThread extends Thread { @Override public void run() { System.out.println("Thread running..."); } } // 使用方式 MyThread thread = new MyThread(); thread.start(); ``` 2. **优点** - **简单直接**:适合快速实现线程逻辑 - **天然支持线程控制**:可直接调用`Thread`类的方法(如`sleep()`、`join()`) 3. **缺点** - **单继承限制**:Java不支持多继承,导致类无法再继承其他父类[^2] - **资源隔离性差**:多个线程无法共享同一实例的成员变量 - **代码耦合度高**:线程逻辑与类定义深度绑定[^4] --- #### 二、实现`Runnable`接口 1. **实现步骤** - 定义类实现`Runnable`接口 - 实现`run()`方法 - 将`Runnable`实例传递给`Thread`对象 ```java class MyRunnable implements Runnable { @Override public void run() { System.out.println("Runnable running..."); } } // 使用方式 Thread thread = new Thread(new MyRunnable()); thread.start(); ``` 2. **优点** - **多实现支持**:可同时继承其他类或实现其他接口[^3] - **资源共享**:多个线程可共享同一个`Runnable`实例的成员变量[^2] - **解耦设计**:线程任务与线程对象分离,便于扩展 3. **缺点** - **使用稍复杂**:需额外创建`Thread`对象并传递参数 - **功能局限性**:无法直接访问`Thread`类的方法(需通过`Thread.currentThread()`获取当前线程) --- #### 三、核心差异对比 | 对比维度 | 继承`Thread`类 | 实现`Runnable`接口 | |--------------------|------------------------------------|------------------------------------| | **继承限制** | 占用唯一继承机会 | 不影响类的继承结构 | | **资源共享能力** | 每个线程独立实例,资源隔离 | 多个线程可共享同一`Runnable`实例 | | **代码复用性** | 低(与线程逻辑绑定) | 高(任务逻辑可独立复用) | | **官方推荐度** | 不推荐 | 推荐[^1] | | **适用场景** | 简单单线程任务 | 多线程协作、资源共享场景 | --- #### 四、为什么推荐`Runnable`接口? 1. **设计灵活性** - 符合面向接口编程原则,支持多态扩展 - 例如线程池可直接接收`Runnable`任务[^1] 2. **资源共享优势** - 多个线程操作同一对象时天然支持同步控制(如售票系统) ```java class TicketSystem implements Runnable { private int tickets = 100; @Override public void run() { while (tickets > 0) { System.out.println(Thread.currentThread().getName() + "售出票号:" + tickets--); } } } ``` 3. **兼容性更强** - `Thread`类本身实现了`Runnable`接口(源码可见) - 可与其他并发工具(如`Callable`、`Future`)无缝结合[^2] ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值