线程的创建方式

最新推荐文章于 2025-08-31 19:52:47 发布

lmd666

最新推荐文章于 2025-08-31 19:52:47 发布

阅读量110

点赞数

CC 4.0 BY-SA版权

分类专栏：多线程 java 文章标签：开发语言 java

本文链接：https://blog.youkuaiyun.com/lmd666/article/details/133679819

java 同时被 2 个专栏收录

25 篇文章

订阅专栏

多线程

1 篇文章

订阅专栏

本文介绍了Java中创建线程的四种方法：1. 继承Thread类并重写run方法；2. 实现Runnable接口；3. 使用线程池；4. 利用CompletableFuture。虽然继承Thread类是最直接的方式，但由于Java的单继承特性，通常推荐使用实现Runnable接口或者线程池。CompletableFuture是JDK1.8新增的特性，提供了更高级的并发处理能力。

真正的创建多线程的方式只有俩种，其他都是这两种的变体.

1. 通过集成thread类，重写run方法，调用start方法来创建多线程。

class MyThread extends Thread{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread p = new MyThread();

        p.start();
        for (int i = 0; i <= 100; i++) {
            System.out.println("===main线程=====" + i);
        }

    }
}

缺点：因为 Java 是单继承的，一个类继承了 Thread 类就不能继承其它类，所以通常不采用这个办法创建多线程。

2. 实现 Runnable 接口

实现Runnable接口

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread myThread = new MThread();

        //4.将此对象作为参数传递到Thread类的构造器当中，创建Thread类的对象
        Thread t1 = new Thread(myThread);

        //5.通过Thread类的对象调用start()
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();
    }


}

匿名内部类形式
通过匿名内部类的形式实现Runnable接口

// 第一步：以匿名内部类的方式创建 Runnable 接口类型的对象
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        // 第二步：编写线程中的逻辑代码
        System.out.println(Thread.currentThread().getName() + " is working");
    }
};
 
// 第三步：创建 Thread 类对象
// 参数1：runnable 对象
// 参数2：线程名称
Thread thread = new Thread(runnable, "thread 003");
 
// 第四步：调用 Thread 对象的 start() 方法启动线程
thread.start();

Lambda 表达式形式

// 编写 Lambda 表达式的口诀：
// 复制小括号
// 写死右箭头
// 落地大括号
 
// 第一步：以匿名内部类的方式创建 Runnable 接口类型的对象
Runnable runnable = () -> {
    // 第二步：编写线程中的逻辑代码
    System.out.println(Thread.currentThread().getName() + " is working");
};
 
// 第三步：创建 Thread 类对象
// 参数1：runnable 对象
// 参数2：线程名称
Thread thread = new Thread(runnable, "thread 004");
 
// 第四步：调用 Thread 对象的 start() 方法启动线程
thread.start();

3. 通过线程池创建

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory，RejectedExecutionHandler handler) 
/*第一个 corePoolSize：线程池的常驻核心线程的数量
maximumPoolSize：线程池的最大线程数量
keepAliveTime:空闲的非核心线程的最大存活时间
unit ：最大存活时间的单位
workQueue：任务队列,被提交但尚未被执行的任务.
threadFactory：表示生成线程池中工作线程的线程工厂,用于创建新线程
handle：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示 数(maxnumPoolSize)时如何来拒绝.*/

4.CompletableFuture

提供了四种静态方法，这个completableFuture是JDK1.8版本新引入的类，是Future的实现类。

public static CompletableFuture<Void>   runAsync(Runnable runnable)
public static CompletableFuture<Void>   runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U>  supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U>  supplyAsync(Supplier<U> supplier, Executor executor)