Java并发编程之Java创建线程的三种方式

thread.start();

}

}

这是一种基于接口的方法，比继承Thread灵活得多，但是它需要创建一个更线程化的对象。打开源代码，可以发现当Runnable实现类的实例作为参数目标传入时，它被分配给当前线程类的目标，而在run()中执行的程序是分配给该目标的run()方法。

public Thread(Runnable target) {

init(null, target, “Thread-” + nextThreadNum(), 0);

}

private void init(ThreadGroup g, Runnable target, String name,

long stackSize, AccessControlContext acc) {

…这里省略部分源码…

this.target = target;

setPriority(priority);

if (parent.inheritableThreadLocals != null)

this.inheritableThreadLocals =

ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

/* Stash the specified stack size in case the VM cares */

this.stackSize = stackSize;

/* Set thread ID */

tid = nextThreadID();

}

@Override

public void run() {

if (target != null) {

target.run();

}

}

三、使用Callable和Future创建线程

使用Callable创建线程类似于使用Runnable接口创建线程。区别在于Callable接口提供call()方法作为线程执行器，而Runnable接口提供run()方法。同时，call()方法可以具有返回值，并且需要FutureTask类来包装Callable对象。

public interface Callable {

V call() throws Exception;

}

步骤：

1、创建Callable接口的实现类，实现call() 方法

2、创建Callable实现类实例，通过FutureTask类来包装Callable对象，该对象封装了Callable对象的call()方法的返回值。

3、将创建的FutureTask对象作为target参数传入，创建Thread线程实例并启动新线程。4、调用FutureTask对象的get方法获取返回值。

执行main方法后，程序输出如下结果：

task 返回值为：1

注意这个任务。get()返回call()方法的结果。那么它在内部是如何工作的呢？首先打开FutureTask的构造方法，可以看到Callable对象作为参数传递给当前实例的Callable成员。

public FutureTask(Callable callable) {

if (callable == null)

throw new NullPointerException();

this.callable = callable;

this.state = NEW;       // ensure visibility of callable

}

同时，将成员变量状态设置为NEW。当任务启动时，它的run方法执行Callable的call()方法。

public void run() {

if (state != NEW ||

!UNSAFE.compareAndSwapObject(this, runnerOffset,

null, Thread.currentThread()))

return;

try {

Callable c = callable;

if (c != null && state == NEW) {

V result;

boolean ran;

try {

//把call()的返回结果复制给result

result = c.call();

ran = true;

} catch (Throwable ex) {

result = null;

ran = false;

setException(ex);

}

if (ran)

//将结果设置给其他变量

set(result);

}

} finally {

// runner must be non-null until state is settled to

// prevent concurrent calls to run()

runner = null;

// state must be re-read after nulling runner to prevent

// leaked interrupts

int s = state;

if (s >= INTERRUPTING)

handlePossibleCancellationInterrupt(s);

}

}

protected void set(V v) {

if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {

//把传过来的值赋值给outcome成员

outcome = v;

UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state

finishCompletion();

}

}

在运行run()方法中的一系列程序之后，call()的返回结果被分配给结果，然后当任务执行时。调用get()方法，获得outcom的值。因此，返回结果是逻辑的。

正如您所看到的，源代码的运行逻辑仍然相对清晰，代码相对容易理解，所以我建议读者有时间查看更多Java的底层源代码，这可以帮助我们理解函数是如何深入实现的。

三种方式的对比

我们已经完成了创建线程的所有三种方法，然后我们将讨论它们的比较。

从实现方式上看，使用Runnable接口和Callable接口的方式基本相同，只有Callable实现的方法体才有返回值，而继承Thread类的方法则使用继承方法，所以实际上可以将这三种方法分为两类进行分析。

1、使用继承Thread类的方式：

优点：编码简单，并且当需要获取当前线程时，可以直接使用它

缺点：因为Java支持单继承，继承继承线程后不能继承其他父类

2、使用Runnable接口和Callable接口的方式：

•优势：

比较灵活，线程只是实现接口，还可以继承其他父类。

通过这种方式，多个线程可以共享一个目标对象，这非常适合于多线程处理相同的资源。

Callable接口的方式还能获取返回值。

•劣势：
编码稍微复杂一些，需要创建更多的对象。
如果想访问当前线程，需要用Thread.currentThread()方法。
一般来说，这两种分类都有各自的优缺点，但实际上后者的缺点不值得一提。一般来说，建议通过接口直接创建线程。毕竟，单一继承的缺点相对较大。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
.(img-e8zeUZiQ-1715737423460)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！