创建线程的几种方式

原创 已于 2023-07-21 22:33:55 修改 · 309 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #开发语言

于 2023-04-02 17:17:10 首次发布

文章目录

创建线程的几种方式

继承Thread类创建线程

​ 通过继承Thread类创建一个线程类，新的 线程子类重写了Thread的run()方法，实现了用户业务代码的并发执行，具体如下：

public class javaJUCstudy {
    public static final int MAX_TURN = 5;
    public static String getCurThreadName(){
        return Thread.currentThread().getName();
    }
    static int threadId = 1;
    public static void main(String[] args) {
        Thread h;
        for (int i = 0; i < 2; i++) {
            h = new TestThread();
            h.start();
        }
        System.out.println(getCurThreadName()+"运行结束");
    }
}
class TestThread extends Thread{
    public TestThread(){
        super("TestThread:"+javaJUCstudy.threadId++);
    }
    public void run(){
        for (int i = 0; i < javaJUCstudy.MAX_TURN; i++) {
            System.out.println(getName()+",轮次:"+i);
        }
        System.out.println(getName()+"结束");
    }
}

​ 执行结果：

main运行结束
TestThread:2,轮次:0
TestThread:1,轮次:0
TestThread:2,轮次:1
TestThread:1,轮次:1
TestThread:2,轮次:2
TestThread:1,轮次:2
TestThread:2,轮次:3
TestThread:1,轮次:3
TestThread:1,轮次:4
TestThread:2,轮次:4
TestThread:2结束
TestThread:1结束

​ TestThread类的关键点是重写了Thread类的run()方法， 将需要并发执行的用户业务代码编写在继承的run()方法中。

实现Runnable接口创建线程目标类

​ 通过继承Thread类并重写它的run()方法只是创建Java线程的一种方式。接下来要介绍的一种方式是通过实现现Runnable接口创建线程目标类，在这之前我们先来看看Thread的run方法。

public class Thread implements Runnable {
    ......
    private Runnable target;//执行目标
    public void run() {
        if (target != null) {
            target.run();//调用执行目标的run方法
        }
    }
    public Thread(Runnable target) {//包含执行目标的构造器
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
}

​ 在Thread类的run()方法中，如果target（执行目标）不为空，就 执行target属性的run()方法。而target属性是Thread类的一个实例属 性，并且target属性的类型为Runnable。

​ Thread类的target属性在什么情况下非空呢？Thread类有一系列 的构造器，其中有多个构造器可以为target属性赋值，这些构造器包 括如下两个：

	1. public Thread(Runnable target)
	2. public Thread(Runnable target，String name)

​ 使用这两个构造器传入target执行目标实例（Runnable实例）， 就可以直接通过Thread类的run()方法以默认方式实现。而我们可以通过创建一个类来实现Runnbale接口来创建Runnable实例。通过实现Runnable接口创建线程类的代码如下：

package suan.JUC;

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

public class RunnableTest {
    public static final int MAX_TURN = 5;
    public static String getCurThreadName(){
        return Thread.currentThread().getName();
    }
    static int threadId = 1;

    public static void main(String[] args) throws InterruptedException {
        Thread h;
        for (int i = 0; i < 2; i++) {
            Runnable r = new TestRunnable();
            h = new Thread(r,"TestThread:"+threadId++);
            h.start();
        }
        Thread.sleep(1000);
        System.out.println(getCurThreadName()+"结束");
    }
}
class TestRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < RunnableTest.MAX_TURN; i++) {
            System.out.println(Thread.currentThread().getName()+",轮次:"+i);
        }
        System.out.println(Thread.currentThread().getName()+"结束");
    }
}

执行结果：

TestThread:1,轮次:0
TestThread:2,轮次:0
TestThread:1,轮次:1
TestThread:2,轮次:1
TestThread:1,轮次:2
TestThread:2,轮次:2
TestThread:1,轮次:3
TestThread:2,轮次:3
TestThread:2,轮次:4
TestThread:1,轮次:4
TestThread:2结束
TestThread:1结束
main结束

​ 实例中静态内部类RunTarget执行目标类，不再是继承Thread线程 类，而是实现Runnable接口，需要异步并发执行的代码逻辑被编写在 它的run()方法中。通过实现Runnable接口的方式创建的执行目标类，如果需要访问 线程的任何属性和方法，必须通过Thread.currentThread()获取当前 的线程对象，通过当前线程对象间接访问。

使用实现Runnable接口创建线程目标类的简便写法

​ 因为Runnable是一个函数式接口，在接口实现时可以使用Lambda 表达式提供匿名实现，来简化我们的代码。改进后如下：

public class RunnableTest {
    public static final int MAX_TURN = 5;
    public static String getCurThreadName(){
        return Thread.currentThread().getName();
    }
    static int threadId = 1;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                for (int j = 0; j < RunnableTest.MAX_TURN; j++) {
                    System.out.println(Thread.currentThread().getName()+",轮次:"+j);
                }
                System.out.println(Thread.currentThread().getName()+"结束");
            },"name"+threadId++).start();
        }
        Thread.sleep(1000);
        System.out.println(getCurThreadName()+"结束");
    }
}

执行结果如下：

name1,轮次:0
name2,轮次:0
name2,轮次:1
name2,轮次:2
name2,轮次:3
name2,轮次:4
name2结束
name1,轮次:1
name1,轮次:2
name1,轮次:3
name1,轮次:4
name1结束
main结束

使用Callable和FutureTask 创建线程

​ 前面已经介绍了继承Thread类或者实现Runnable接口这两种方式 来创建线程类，但是这两种方式有一个共同的缺陷：不能获取异步执 行的结果。为了解决异步执行的结果问题，Java语言在1.5版本之后提供了一 种新的多线程创建方法：通过Callable接口和FutureTask类相结合创 建线程。

Callable接口

Callable接口位于java.util.concurrent包中，查看它的Java源 代码，如下：

package java.util.concurrent;
@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

Callable接口是一个泛型接口，也是一个“函数式接口”。其唯 一的抽象方法call()有返回值，返回值的类型为Callable接口的泛型 形参类型。call()抽象方法还有一个Exception的异常声明，容许方法 的实现版本的内部异常直接抛出，并且可以不予捕获。但Callable接口不能像Runnable接口那样作为Thread线程实例的taiget使用，这就要引入RunnableFuture接口了。

RunnableFuture接口

RunnableFuture接口与 Runnable接口、Thread类紧密相关，RunnableFuture接口实现了两个目标：一是可以作为Thread线程 实例的target实例，二是可以获取异步执行的结果。

package java.util.concurrent;
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

RunnableFuture继承了Runnable接口，从 而保证了其实例可以作为Thread线程实例的target目标；同时， RunnableFuture通过继承Future接口，保证了可以获取未来的异步执 行结果。这里又需要引入Future接口了。

Future接口

Future接口至少提供了三大功能：

（1）能够取消异步执行中的任务。

（2）判断异步任务是否执行完成。

（3）获取异步任务完成后的执行结果。

Future接口的代码如下：

package java.util.concurrent;
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);//取消异步任务的执行。
    boolean isCancelled();//获取异步任务的取消状态。如果任务完成前被取消，就返回true。
    boolean isDone();//获取异步任务的执行状态。如果任务执行结束，就返回true。
    V get() throws InterruptedException, ExecutionException;
    //获取异步任务执行的结果。注意，这个方法的调用是阻塞性的。如果异步任务没有执行完成，异步结果获取线程（调用线程）会一直被阻塞，一直阻塞到异步任务执行完成，其异步结果返回给调用线程。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
    //设置时限，（调用线程）阻塞性地获取异步任务执行的结果。该方法的调用也是阻塞性的，但是结果获取线程（调用线程）会有一个阻塞时长限制，不会无限制地阻塞和等待，如果其阻塞时间超过设定的timeout时间，该方法将抛出异常，调用线程可捕获此异常。
}
FutureTask类

​ FutureTask类是Future接口的实现类，提供了对异步任务的操作 的具体实现。但是，FutureTask类不仅实现了Future接口，还实现了 Runnable接口，或者更加准确地说，FutureTask类实现了 RunnableFuture接口。

​ FutureTask实现了 RunnableFuture接口，而RunnableFuture接口继承了Runnable接口和 Future接口，所以FutureTask既能作为一个Runnable类型的target执 行目标直接被Thread执行，又能作为Future异步任务来获取Callable 的计算结果。

机构图如下：

在这里插入图片描述

使用Callable和FutureTask创建线程的具体步骤

通过FutureTask类和Callable接口的联合使用可以创建能够获取 异步执行结果的线程，具体步骤如下：

（1）创建一个Callable接口的实现类，并实现其call()方法，编 写好异步执行的具体逻辑，可以有返回值。

（2）使用Callable实现类的实例构造一个FutureTask实例。

（3）使用FutureTask实例作为Thread构造器的target入参，构造 新的Thread线程实例。

（4）调用Thread实例的start()方法启动新线程，启动新线程的 run()方法并发执行。其内部的执行过程为：启动Thread实例的run() 方法并发执行后，会执行FutureTask实例的run()方法，最终会并发执 行Callable实现类的call()方法。

（5）调用FutureTask对象的get()方法阻塞性地获得并发线程的 执行结果。

代码如下：

package suan.JUC;

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

public class FutureTaskTest {
    public static final int MAX_TURN = 5;
    public static final int COMPUTE_TIMES = 100000000;
    public static String getCurThreadName(){
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws InterruptedException {
        ReturnTask task = new ReturnTask();
        FutureTask<Long> futureTask = new FutureTask<>(task);
        Thread thread = new Thread(futureTask,"有返回值的异步线程");
        thread.start();
        Thread.sleep(1000);
        System.out.println(getCurThreadName()+"等一会");
        for (int i = 0; i < COMPUTE_TIMES/2; i++) {
            int j = i * 10000;
        }
        System.out.println(getCurThreadName()+"获取异步执行的结果");
        try {
            System.out.println(thread.getName()+"线程占用时间"+futureTask.get());
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("运行结束");
    }
}
class ReturnTask implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        long startTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+"线程开始运行");
        Thread.sleep(1000);
        for (int i = 0; i < FutureTaskTest.COMPUTE_TIMES; i++) {
            int j = i * 10000;
        }
        long useTime = System.currentTimeMillis() - startTime;
        System.out.println(Thread.currentThread().getName()+"线程运行结束");
        return useTime;
    }
}

运行结果如下：

有返回值的异步线程线程开始运行
main等一会
有返回值的异步线程线程运行结束
main获取异步执行的结果
有返回值的异步线程线程占用时间1010
运行结束

通过线程池创建线程

前面的示例中，所创建的Thread实例在执行完成之后都销毁了， 这些线程实例都是不可复用的。实际上创建一个线程实例在时间成 本、资源耗费上都很高，在高并发的场景中，断然不 能频繁进行线程实例的创建与销毁，而是需要对已经创建好的线程实 例进行复用，这就涉及线程池的技术。Java中提供了一个静态工厂来 创建不同的线程池，该静态工厂为Executors工厂类。

向ExecutorService线程池提交异步执行target目标任务的常用方法有：

  1. 执行一个 Runnable类型的target执行目标实例，无返回 。

​ void execute(Runnable command);

  1. 提交一个 Callable类型的target执行目标实例, 返回一个 Future异步任务实例

​ Future submit(Callable task);

  1. 提交一个 Runnable类型的target执行目标实例, 返回一个 Future异步任务实例

​ Future submit(Runnable task);

代码实例：

package suan.JUC;

import java.util.concurrent.*;

public class ExecutorsTest {
    public static final int MAX_TURN = 5;
    public static final int COMPUTE_TIMES = 100000000;
    private static ExecutorService pool = Executors.newFixedThreadPool(3);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        pool.execute(new demoThread());
        pool.execute(()->{
            for (int i = 0; i < MAX_TURN; i++) {
                System.out.println(Thread.currentThread().getName()+", 轮次: "+i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Future<Long> submit = pool.submit(new ReturnTaskTest());
        Long result = (Long)submit.get();
        System.out.println("异步执行的结果："+result);
        Thread.sleep(5000);
        System.out.println(Thread.currentThread().getName()+"结束");
    }
}
class demoThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < ExecutorsTest.MAX_TURN; i++) {
            System.out.println(Thread.currentThread().getName()+", 轮次: "+ i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class ReturnTaskTest implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        long startTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+"线程开始运行");
        Thread.sleep(1000);
        for (int i = 0; i < ExecutorsTest.MAX_TURN; i++) {
            System.out.println(Thread.currentThread().getName()+", 轮次: "+i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long useTime = System.currentTimeMillis() - startTime;
        System.out.println(Thread.currentThread().getName()+"线程运行结束");
        return useTime;
    }
}

执行结果：

pool-1-thread-1, 轮次: 0
pool-1-thread-1, 轮次: 1
pool-1-thread-1, 轮次: 2
pool-1-thread-2, 轮次: 0
pool-1-thread-3线程开始运行
pool-1-thread-1, 轮次: 3
pool-1-thread-2, 轮次: 1
pool-1-thread-1, 轮次: 4
pool-1-thread-2, 轮次: 2
pool-1-thread-2, 轮次: 3
pool-1-thread-2, 轮次: 4
pool-1-thread-3, 轮次: 0
pool-1-thread-3, 轮次: 1
pool-1-thread-3, 轮次: 2
pool-1-thread-3, 轮次: 3
pool-1-thread-3, 轮次: 4
pool-1-thread-3线程运行结束
异步执行的结果：1086
main结束

此时虽然main方法的线程结束了，但是线程池中的线程还没有结束，程序还没有停止。

在这里插入图片描述

975310
关注
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
多线程系列(十九) -Future使用详解
程序员志哥的博客
03-11 1546
在前几篇线程系列文章中，我们介绍了线程池的相关技术，任务执行类只需要实Runnable接口，然后交给线程池，就可以轻松的实现异步执行多个任务的目标，提升程序的执行效率，比如如下异步执行任务下载。
【Java】创建线程对象两种方式
weixin_33724570的博客
03-17 148
1.继承Thread类，重载run方法； Thread t = new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }); 2.实现Runnable接口，实现run方法； publi...
Callable+Future获取执行结果
liyonghui123的专栏
12-22 353
    public class Test { public static void main(String[] args) { ExecutorService executor = Executors.newCachedThreadPool(); Task task = new Task(); Future&lt;Intege...
【JAVA并发学习三】创建线程对象
Monkey__z的博客
09-12 690
一 创建线程类在Java中实现多线程，主要依靠java.lang.Thread类，每一个Thread对象都是一个线程，创建一个新的线程类的方法有两种：继承Thread类、实现Runable接口
Java多线程学习（Future接口）
weixin_44485253的博客
11-06 666
关于JUC的Future实现异步调度任务
java 创建线程的几种方式
08-31
总结来说，虽然两种方式都能创建线程，但实现Runnable接口通常更受欢迎，因为它更灵活，且可以避免由于单继承带来的问题。在实际开发中，根据项目需求和代码设计选择合适的方法。同时，理解线程的并发执行机制，正确...
当阿里面试官问我：Java创建线程有几种方式？我就知道问题没那么简单
01-21
Java 创建线程有两种方式： 继承Thread类，并重写run()方法 实现Runnable接口，覆盖接口中的run()方法，并把Runnable接口的实现扔给Thread 面试官：（拿出一张白纸）那你把这两种方式写一下吧！ 小哥：（这有何难！...
Java创建线程的七种方式
最新发布
weixin_68489989的博客
07-17 947
Java创建线程的七种方式
Java创建多线程的几种方式详解
weixin_45797022的博客
07-08 1490
线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制：它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可具体可以看看这篇。线程：进程中最小的执行单元，作用是负责当前进程中程序的运行。一个进程中至少有一个线程，一个进程还可以有多个线程，这样的应用程序就称之为多线程程序。下面介绍下创建多线程的几种方式。进程：在内存中执行的应用程序。
Java多线程 - Java创建线程的4种方式
qq_20236937的博客
02-03 372
Java多线程 - Java创建线程的4种方式
【多线程】创建线程的五种方法
m0_74105656的博客
03-13 1129
Thread类创建线程的五种方式,以及Sleep清空标志位的详细原因以及解决方法.
java 创建线程的三种方式、创建线程池的四种方式
SmileTimLi的博客
02-23 4万+
概要： java创建线程的三种方式： 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式： newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程 newFixedThread...
线程的创建方式
分享技术和学习技术两不误
11-07 136
继承Thread类和实现Runnable优先使用谁？从本质来说Thread类它也是实现Runnable接口的，但继承具有局限只能单继承。相对而言Thread共享数据需经过处理如加static关键字等一系列处理而Runnable天然的共享数据，建议优先考虑实现接口的方法创建线程。Callable和Runnable 比较谁更强大？从实现run()方法就可以看出Callable 更强大一些，它可以有返回值以及可以抛出异常而Runnable只能捕获异常线程池好处提高响应速度，降低资源消耗，方便管理。
多线程 | FutureTask 执行流程
码农UP2U
05-02 1176
在 Java 中可以用来创建线程的方式很多，比如由 Java 提供的 Thread、Runnable 等。本文章来介绍使用 FutureTask 创建线程，以及其流程。 Thread 和 Runnable 的问题 众所周知，使用 Thread、Runnable 创建线程是非常方便的，只要实现 线程的 run 方法即可。但是通过 Thread、Runnable 实现 run 方法创建的线程是无法获取返回结果的，原因是线程方法 run 本身是没有返回值的。但是在很多场景中...
使用Callable和Future创建线程
欧阳子遥的博客
11-22 2870
编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 在runThread(int num)函数中执行线程，创建Callable线程，Callable线程需要执行求第num项斐波那契数列的值，最后在runThread函数中获取Callable线程执行的结果，并打印输出。 斐波那契数列（Fibonacci数列） 这个数列从第3项开始，之后的每一...
创建线程类的方式
qq_43156009的博客
09-27 303
这里写目录标题先导继承Thread线程类 先导 一个线程是执行程序中的一个线程。Java 虚拟机允许应用程序同时运行多个执行线程。 每个线程都有一个优先级。具有较高优先级的线程优先于具有较低优先级的线程执行。每个线程可能也可能不标记为守 护进程。当在某个线程中运行的代码创建一个新Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时，新线程才是守护线程。 当 Java 虚拟机启动时，通常有一个非守护线程（通常调用main某个指定类的方法 ）。Java 虚
线程创建的四种方式
热门推荐
m0_37840000的博客
03-30 18万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 --...
java创建线程几种方式
02-19
在Java中，有几种方式可以创建线程，包括： 1. 继承Thread类：可以创建一个继承自Thread类的子类，并重写其run()方法来定义线程的执行逻辑。然后通过创建子类的实例并调用start()方法来启动线程。 2. 实现Runnable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值