Java进阶（5）——创建多线程的方法extends Thread和implements Runnable的对比 &amp； 线程池及常用的线程池

最新推荐文章于 2025-05-28 07:52:30 发布
原创 最新推荐文章于 2025-05-28 07:52:30 发布 · 962 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单元测试 #功能测试 #学习

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以戳这里获取

两者的对比

实现一个自定义的线程类，可以有继承Thread类或者实现Runnable接口这两种方式，它们之间有什么优劣呢？

  • 由于Java“单继承，多实现”的特性，Runnable接口使用起来比Thread更灵活。
  • Runnable接口出现更符合面向对象，将线程单独进行对象的封装。
  • Runnable接口出现，降低了线程对象和线程任务的耦合性。
  • 如果使用线程时不需要使用Thread类的诸多方法，显然使用Runnable接口更为轻量。

所以，我们通常优先使用“实现Runnable接口”这种方式来自定义线程类。

线程池

是啥？为啥用？

线程池是一种用于管理和复用线程的机制。它是一种线程管理的抽象概念，可以有效地管理线程的创建、执行和销毁，以提高应用程序的性能和资源利用率。

线程池中包含一组预先创建的线程，这些线程可以被重复使用来执行任务。当有任务需要执行时，线程池中的线程会被分配给任务，并在任务完成后返回线程池，以便可以被其他任务复用。这样可以避免频繁地创建和销毁线程，减少了线程创建和销毁的开销，提高了系统的响应速度和资源利用率。

使用线程池主要有以下三个原因：

  1. 创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
  2. 控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
  3. 可以对线程做统一管理。

结合案例理解常用的线程池

Executors类中提供的几个静态方法来创建线程池

继承Runnable接口的工人实体类

name：工人名字，

workTime：工作时间，用java的毫秒模拟现实中的1分钟

materials：物料的数量，假设一共有100个物料；

package com.tianju.book.jpa.syn;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/\*\*
 \* 工厂仿真的工人
 \*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Worker implements Runnable{
    private String name;

    private Integer workTime;

    private static Integer materials=100; // 物料数量

    @Override
    public void run() {
        System.out.println(name+"开始工作");
        try {
            Thread.sleep(workTime); // 模拟工作时间
            materials--; // 每次消耗1个物料
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(name+"工作完成，耗时"+workTime+"分钟，"+"当前剩余物料："+materials);
    }
}

newSingleThreadExecutor（单线程）

创建一个单线程的线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

有且仅有一个核心线程（ corePoolSize == maximumPoolSize=1），使用了LinkedBlockingQueue（容量很大），所以，不会创建非核心线程。所有任务按照先来先执行的顺序执行。如果这个唯一的线程不空闲，那么新来的任务会存储在任务队列里等待执行。

package com.tianju.book.jpa.syn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/\*\*
 \* 进行工厂的仿真
 \*/
public class FactorySimulationSingle {

    public static void main(String[] args) {
        // 工人池，单线程的线程池
        ExecutorService workerPool = Executors.newSingleThreadExecutor();
        for (int i= 1;i<10;i++){
            Worker worker = new Worker("worker" + i, i \* 10);
            workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
        }
        Thread thread2 = new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                Worker worker = new Worker("TH-worker" + i, i \* 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
        });
        thread2.start();

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        workerPool.shutdown();
    }
}

在这里插入图片描述

newFixedThreadPool（加锁）

创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

核心线程数量和总线程数量相等，都是传入的参数nThreads，所以只能创建核心线程，不能创建非核心线程。因为LinkedBlockingQueue的默认大小是Integer.MAX_VALUE，故如果核心线程空闲，则交给核心线程处理；如果核心线程不空闲，则入列等待，直到核心线程空闲。

与CachedThreadPool的区别：

  • 因为 corePoolSize == maximumPoolSize ，所以FixedThreadPool只会创建核心线程。 而CachedThreadPool因为corePoolSize=0，所以只会创建非核心线程。
  • 在 getTask() 方法，如果队列里没有任务可取，线程会一直阻塞在 LinkedBlockingQueue.take() ，线程不会被回收。 CachedThreadPool会在60s后收回。
  • 由于线程不会被回收，会一直卡在阻塞，所以没有任务的情况下， FixedThreadPool占用资源更多。
  • 都几乎不会触发拒绝策略，但是原理不同。FixedThreadPool是因为阻塞队列可以很大（最大为Integer最大值），故几乎不会触发拒绝策略；CachedThreadPool是因为线程池很大（最大为Integer最大值），几乎不会导致线程数量大于最大线程数，故几乎不会触发拒绝策略。

ExecutorService workerPool = Executors.newFixedThreadPool(1);

设置线程池中线程数量为1，此时就等同于newSingleThreadExecutor

在这里插入图片描述

package com.tianju.book.jpa.syn;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/\*\*
 \* 进行工厂的仿真
 \*/
public class FactorySimulation {

    public static void main(String[] args) {
        // 工人池，固定大小为5
        ExecutorService workerPool = Executors.newFixedThreadPool(5);

        for (int i= 1;i<10;i++){
            Worker worker = new Worker("worker" + i, 1);
            workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
        }

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                Worker worker = new Worker("TH1-worker" + i, i \* 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                Worker worker = new Worker("TH2-worker" + i, i \* 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
        });

        thread1.start();
        thread2.start();

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        workerPool.shutdown();
    }
}

在这里插入图片描述

newCachedThreadPool

创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说VM)能够创建的最大线程大小。

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX\_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

CacheThreadPool的运行流程如下：

  1. 提交任务进线程池。
  2. 因为corePoolSize为0的关系，不创建核心线程，线程池最大为Integer.MAX_VALUE。
  3. 尝试将任务添加到SynchronousQueue队列。
  4. 如果SynchronousQueue入列成功，等待被当前运行的线程空闲后拉取执行。如果当前没有空闲线程，那么就创建一个非核心线程，然后从SynchronousQueue拉取任务并在当前线程执行。
  5. 如果SynchronousQueue已有任务在等待，入列操作将会阻塞。

当需要执行很多短时间的任务时，CacheThreadPool的线程复用率比较高， 会显著的提高性能。而且线程60s后会回收，意味着即使没有任务进来，CacheThreadPool并不会占用很多资源。

package com.tianju.book.jpa.syn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/\*\*
 \* 进行工厂的仿真
 \*/
public class FactorySimulationCached {

    public static void main(String[] args) {
        // 工人池，固定大小为5 
        ExecutorService workerPool = Executors.newCachedThreadPool();
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                Worker worker = new Worker("TH1\_worker" + i, i \* 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                Worker worker = new Worker("TH2\_worker" + i, i \* 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
        });

        thread1.start();
        thread2.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        workerPool.shutdown();
    }
}

在这里插入图片描述

newScheduledThreadPool（定时任务）

创建一个定长线程池，支持定时及周期性任务执行。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX\_VALUE,
          DEFAULT\_KEEPALIVE\_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

在这里插入图片描述

package com.tianju.book.jpa.syn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/\*\*
 \* 进行工厂的仿真
 \*/
public class FactorySimulationScheduled {

    public static void main(String[] args) {
        // 工人池，固定大小为5 创建大小为20的定时线程池
        ScheduledExecutorService workerPool = Executors.newScheduledThreadPool(20);
        workerPool.schedule(new Worker("worker1,延迟1秒",10) ,1, TimeUnit.SECONDS);
        workerPool.scheduleAtFixedRate(new Worker("worker2,延迟2秒,后续每3秒执行1次",10), 2,3,TimeUnit.SECONDS);
        workerPool.scheduleAtFixedRate(new Worker("worker2,延迟2秒,后续每5秒执行1次",10), 3,5,TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        workerPool.shutdown();
    }
}

newSingleThreadScheduledExecutor

创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

在这里插入图片描述

package com.tianju.book.jpa.syn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/\*\*
 \* 进行工厂的仿真
 \*/
public class FactorySimulationSingleS {

    public static void main(String[] args) {
        // 工人池，固定大小为5
        ScheduledExecutorService workerPool = Executors.newSingleThreadScheduledExecutor();
        Thread thread1 = new Thread(() -> {
            for (int i =1;i<10;i++){
                workerPool.scheduleAtFixedRate(
                        new Worker("worker1-"+i, 3),
                        1, 3, TimeUnit.SECONDS);
            }

        });
        Thread thread2 = new Thread(() -> {
            for (int i=1;i<10;i++){
                workerPool.scheduleAtFixedRate(
                        new Worker("worker2-"+i, 3),
                        1, 3, TimeUnit.SECONDS);
            }

        });
        thread1.start();
        thread2.start();

        try {
            Thread.sleep(20000);


![img](https://img-blog.csdnimg.cn/img_convert/2be0380bfc2267287887e8c60cf576b3.png)
![img](https://img-blog.csdnimg.cn/img_convert/450b2fce6c82497092e4cb336e0b5887.png)
![img](https://img-blog.csdnimg.cn/img_convert/735aa5d78c44c6e1570e635eeca05266.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618631832)**

);
            }

        });
        thread1.start();
        thread2.start();

        try {
            Thread.sleep(20000);


[外链图片转存中...(img-TYZDnglU-1715791916534)]
[外链图片转存中...(img-QrgMYP42-1715791916535)]
[外链图片转存中...(img-mSTlDf7i-1715791916535)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618631832)**
2401_84563438
关注
Java-通过Runnable接口实现多线程
Broken_x的博客
09-02 1960
在Java中，实现多线程的两种基本方式之一是通过实现Runnable接口。这种方式相比于继承Thread类有其独特的优点，如避免了单继承的局限性、降低了线程对象和线程任务的耦合性，以及增强了程序的可扩展性。下面将详细介绍如何通过Runnable接口实现多线程，并给出一些多线程状态操作的代码示例。
Java多线程的实现（进程与线程的概念、继承Thread类实现多线程、实现Runnable接口实现多线程、继承Thread类与实现Runnable接口的区别、实现Callable接口实现多线程）
zhao_miao的博客
11-12 1353
文章目录1 进程与线程1.1 进程与线程的概念1.2 进程&amp;amp;amp;amp;amp;amp;amp;amp;线程2 Java多线程实现2.1 继承Thread类实现多线程2.2 实现Runnable接口来实现多线程2.3 继承Thread类与实现Runnable借口的区别 1 进程与线程 1.1 进程与线程的概念 什么是进程？   进程： 操作系统中一个程序的执行周期。（比如我们想要在电脑上登录QQ，从双击qq按钮----&amp;amp;amp;amp;amp;amp;amp;gt;
Java 中的“implements Runnable” 和“extends Thread”
didingyun4257的博客
09-18 460
知识点 “implements Runnable” 和“extends Thread”的不同 具体分析 最近在学习Android中的Handler消息传递机制时，创建新线程有两种方式：一种是实现Runnable接口（implements Runnable）而另一种则是继承Threa...
Java中implements Runnable与extends Thread的对比
最新发布
qq_29715355的博客
05-28 303
这两种方式都能实现多线程功能，但在实际应用中各有特点。理解它们的区别有助于开发者根据具体需求选择合适的方式来创建线程。在Java多线程编程中，创建线程有两种常见的方式：实现。
extends Thread 与 implements Runnable 的区别
热门推荐
05-01 4万+
1、通过实现Runnable接口创建线程 (1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 (2).创建Runnable接口实现类的对象。 (3).创建一个Thread类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承） (4).调用Thread对象的start()方法，启动线程
Java进阶（5）——创建多线程的方法extends Thread和implements Runnable的对比 & 线程池及常用的线程池
Arya的博客，专注后端领域
08-22 1658
1.创建多线程两种方法，继承thread，实现runnable，常用runnable； 2.线程池，管理线程，控制并发； 3.常用的线程池，newFixedThreadPool定容量； 4.newCachedThreadPool容量大，Integer.MAX_VALUE； 5.newScheduledThreadPool（定时任务），newSingleThreadScheduledExecutor单线程的线程池的定时任务； 6.newSingleThreadExecutor（单线程），单线程的线程池；
java extends thread_Java多线程extends Thread和implements Runnable
weixin_31898831的博客
02-13 347
大家都知道，要实现Java多线程的两种方式　　a：是直接继承Thread类，b：是实现Runnable接口。先上代码：a：是直接继承Thread类，public class ThreadDemo1 extends Thread {public void run(){//Thread.currentThread().getName() 和 this.getName()都可以用来获得线程的名称Syst...
Java多线程复习与巩固（六）--线程池ThreadPoolExecutor详解
CSDN文章已停止维护，后续文章会在 https://blog.hufeifei.cn 持续更新
08-19 5183
1. 为什么要使用线程池 线程创建与销毁都耗费时间，对于大量的短暂任务如果仍使用“创建-&amp;amp;amp;amp;amp;amp;amp;gt;执行任务-&amp;amp;amp;amp;amp;amp;amp;gt;销毁”的简单模式，将极大地降低线程的使用效率(一个线程仅仅处理一个短暂的任务就被销毁了)。在这种情况下，为了提高线程的使用效率，我们使用缓存池的策略让线程执行任务后不立即销毁而是等待着处理下一个任务。 2. 使用Executors工具类创建线程池 Executors是线程池框
【java多线程编程】三种多线程的实现方式
taojin12的博客
01-01 4万+
文章目录前言进程与线程继承Thread类，实现多线程FAQ 为什么多线程的启动不直接使用run（）方法而必须使用Thread类中start（）方法呢？基于Runnable接口实现多线程Thread 与 Runnable 的关系Callable实现多线程线程运行状态 前言 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;在java语言最大的特点是支持多线程的开发（也是为数不多...
java多线程：线程同步synchronized（不同步的问题、队列与锁），死锁的产生和解决
LifeGoesOn
08-18 1409
0、不同步的问题 并发的线程不安全问题： 多个线程同时操作同一个对象，如果控制不好，就会产生问题，叫做线程不安全。 我们来看三个比较经典的案例来说明线程不安全的问题。 0.1 订票问题 例如前面说过的黄牛订票问题，可能出现负数或相同。 线程创建方式&amp;&amp;黄牛订票模拟 0.2 银行取钱 再来看一个取钱的例子： /* 模拟一个账户 */ class Account{ int money; String name; public Account(int money,
Java多线程之线程同步问题
vm04580
03-16 365
线程同步 产生原因：每一个线程轮番抢占资源 1、不同步问题 //多个线程同时处理数据，不同步 class MyThread implements Runnable{ private int ticket = 10;//总共是10张票 @Override public void run() { while (this.ticket &amp;gt; 0){//还有余票...
java中的 extends Thread 与 implements Runnable
江江呀
09-24 1080
**一、extends Thread 与 implements Runnable ** 例子： package com.Thread.implements_extends; //实现Runnable接口 class ImplementsRunnable implements Runnable { private int num = 0; public void run() { num...
java实现线程extends Thread
Mao的博客
07-23 456
java实现线程extends Thread 通过继承Thread类实现线程 TestThread1.java /* 测试线程1 */ public class TestThread1 { public static void main(String args[]) { Runner1 r = new Runner1(); //调用run()方法 //r.r...
extends thread java_java学习之- 线程继承Thread类
weixin_33093437的博客
02-16 679
标签(空格分隔)： 线程在java。lang包中有个Thread子类,大家可以自行查阅文档，及范例；如何在自定义的代码中，自定义一个线程呢？1.通过对api的查找，java已经提供了对线程这类事物的描述，就是Thread类，创建线程的第一种方式，就是继承Thread类：2.public void run(),如果该线程是使用独立的Runnable运行对象的run方法，否则该方法不执行任何操作并返回...
java 多线程之 extends Thread
比嗨皮兔
01-05 1万+
线程的实现方式 java 多线程之 extends Thread java 多线程之 implements Runnable java 多线程之 implements Callable 线程池的使用 线程池简介 ThreadPoolExecutor java 线程池之 newScheduledTh......
Java - 多线程 Extends Thread实现
arskdngr98K的博客
02-19 363
Java - 多线程基础 继承Thread实现
extend Thread 和 implements Runnable
IOS -Step by step
04-13 1734
原文地址：Thread 和 implements Runnable" href="http://blog.sina.com.cn/s/blog_58515189010006om.html" target="_blank">extend Thread 和 implements Runnable作者：test 一个Thread的实例只能产生一个线程 or: 同一实例(Runnable实例)
java创建线程implement runnable 和 extends thread 比较
Great_Smile的专栏
12-31 7838
我们都知道java实现线程有两种方法 一。继承Thread类 二。实现Runnable接口 我们知道从代码上看 第二种方法扩张性更好，因为java的单继承特性 看到很多说法他们之间有一个区别是：实现Runnable接口才能实现资源共享。 并且附有类似一下的实例： //Implement Runnable Interface... class ImplementsRunnab
JAVA中实现多线程的两种方式
FlywindMouse的专栏
11-15 1828
java实现多线程有两种方法 1、继承Thread类 2、实现Runnable接口 两种实现方式的共同点： 不论用哪种方法，都必须用Thread（如果是Thead子类则用它本身）产生线程，然后再调用start()方法。 两种实现方式的不同点： 1、继承Thread类只能是单继承，而实现Runnable接口则可以实现多继承（即如果有一个类，它已继承了某个类，又想实现多线程
Java多线程：对比Thread与Runnable创建方式
"Java编程中，创建多线程有两种主要方式：继承Thread类和实现Runnable接口。这两种方式在实现多线程上有各自的特点和适用场景。下面将详细对比这两种方式，并通过实例进行说明。\n\n一、对比两种方式\n\n（1）对比\n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值