多线程&&线程池

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

#多线程 #线程池

多线程

多线程的实现方式主要有三种

  • extends Thread

  • implements Runnable

  • implements Callable

实现接口 VS 继承 Thread

实现接口会更好一些，因为：

  • Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
  • 类可能只要求可执行就行，继承整个 Thread 类开销过大。

 

  • extends Thread

继承 Thread 的代码

public class ExtendsThread extends Thread {
    /**
     * 线程名称
     */
    private String threadName;
 
    /**
     * 构造函数
     *
     * @param threadName 线程名称
     */
    public ExtendsThread(String threadName) {
        this.threadName = threadName;
    }
 
    /**
     * 重写run方式
     */
    @Override
    public void run() {
        System.out.println(threadName);
    }
}
public class ThreadMain {
    public static void main(String[] args) {
        ExtendsThread extendsThread = new ExtendsThread("1");
        extendsThread.start();
        extendsThread = new ExtendsThread("2");
        extendsThread.start();
    }
}

  • implements Runnable

实现Runnable接口

public class ThreadMain {
    public static void main(String[] args) {
        ThreadImplRunnable threadImplRunnable = new ThreadImplRunnable("Thread1");
        new Thread(threadImplRunnable).start();
        threadImplRunnable = new ThreadImplRunnable("Thread2");
        new Thread(threadImplRunnable).start();
        System.out.println("end");
    }
}
public class ThreadImplRunnable implements Runnable {
    /**
     * 线程名称
     */
    private String threadName;
 
    /**
     * 构造函数
     *
     * @param threadName 线程名称
     */
    public ThreadImplRunnable(String threadName) {
        this.threadName = threadName;
    }
    /**
     * 重写run方法
     */
    @Override
    public void run() {
        System.out.println(threadName);
    }
}
end
Thread1
Thread2

  • implements Callable

实现Callable接口主要是可以获取到返回值,futureTask.get() 获取返回的值

public class ThreadImplCallable<T> implements Callable<T> {
    /**
     * 线程名称
     */
    private String threadName;
 
    /**
     * 构造函数
     *
     * @param threadName 线程名称
     */
    public ThreadImplCallable(String threadName) {
        this.threadName = threadName;
    }
    /**
     * 重写call方法
     */
    @Override
    public T call() throws Exception {
        System.out.println(threadName);
        return (T)threadName;
    }
}
public class ThreadMain {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> threadImplCallable = new ThreadImplCallable<>("Thread1");
        FutureTask<String> futureTask = new FutureTask<>(threadImplCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        String rValue = futureTask.get();
        System.out.println("Thread1 return value is " + rValue);
        threadImplCallable = new ThreadImplCallable<>("Thread2");
        futureTask = new FutureTask<>(threadImplCallable);
        thread = new Thread(futureTask);
        thread.start();
        rValue = futureTask.get();
        System.out.println("Thread2 return value is " + rValue);
 
        System.out.println("end");
    }
}
Thread1
Thread1 return value is Thread1
Thread2
Thread2 return value is Thread2
end

 

线程池

 java 线程池的顶级接口是 Executor, 只定义了一个方法 execute，ExecutorService继承接口Executor接口，并定义了其他的相关的接口，ExecutorService下面有一个继承的抽象类AbstractExecutorService和实现了定时调度的接口ScheduledExecutorService，而又有两个类继承抽象类，分别是ThreadPoolExecutor和ForkJoinPool，而ScheduledThreadPoolExecutor则实现接口实现ScheduledExecutorService接口和继承ThreadPoolExecutor类，基本的关系就是这样的，而且基本常用的封装方法都在Executors类中，只要 Executors.xxxx 就可以应用对应的封装的方法。

Executor

Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。

线程池种类

  • newSingleThreadExecutor

一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "\t开始发车啦....");
            });
        }
    }
}
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....
pool-1-thread-1    开始发车啦....

  • newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "\t开始发车啦....");
            });
        }
    }
}
pool-1-thread-1    开始发车啦....
pool-1-thread-4    开始发车啦....
pool-1-thread-3    开始发车啦....
pool-1-thread-2    开始发车啦....
pool-1-thread-6    开始发车啦....
pool-1-thread-7    开始发车啦....
pool-1-thread-5    开始发车啦....
pool-1-thread-8    开始发车啦....
pool-1-thread-9    开始发车啦....
pool-1-thread-10 开始发车啦....

  • newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲的线程，当任务数增加时，此线程池又添加新线程来处理任务。

    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "\t开始发车啦....");
            });
        }
    }
pool-1-thread-1	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-1	开始发车啦....
pool-1-thread-7	开始发车啦....
pool-1-thread-5	开始发车啦....
pool-1-thread-6	开始发车啦....
pool-1-thread-4	开始发车啦....

  • newScheduledThreadPool

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

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 10; i++) {
            pool.schedule(() -> {
                System.out.println(Thread.currentThread().getName() + "\t开始发车啦....");
            }, 10, TimeUnit.SECONDS);
        }
    }
}
pool-1-thread-1	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-1	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-7	开始发车啦....
pool-1-thread-8	开始发车啦....
pool-1-thread-6	开始发车啦....
pool-1-thread-5	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-4	开始发车啦....

上面演示的是延迟10秒执行任务,如果想要执行周期性的任务可以用下面的方式，每秒执行一次。

public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
        //pool.scheduleWithFixedDelay也可以
        pool.scheduleAtFixedRate(() -> {
                System.out.println(Thread.currentThread().getName() + "\t开始发车啦....");
        }, 1, 1, TimeUnit.SECONDS);
}

pool-1-thread-1	开始发车啦....
pool-1-thread-1	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-1	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-2	开始发车啦....
pool-1-thread-4	开始发车啦....
pool-1-thread-1	开始发车啦....
pool-1-thread-5	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-3	开始发车啦....
pool-1-thread-9	开始发车啦....
pool-1-thread-9	开始发车啦....

  • newWorkStealingPool

newWorkStealingPool是jdk1.8才有的，会根据所需的并行层次来动态创建和关闭线程，通过使用多个队列减少竞争，底层用的ForkJoinPool来实现的。ForkJoinPool的优势在于，可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。

newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中

package org.jeecg.modules.exam.entity;

import org.junit.Test;

import java.util.concurrent.*;

public class WorkStealingPoolTest {
    // 线程数
    private static final int threads = 10;
    // 用于计数线程是否执行完成
    CountDownLatch countDownLatch = new CountDownLatch(threads);

    /**
     * newFixedThreadPool execute
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test1() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
            executorService.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName());
                } catch (Exception e) {
                    System.out.println(e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newFixedThreadPool submit submit
     */
    @Test
    public void test2() throws InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
//            Callable 带返回值
            executorService.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        countDownLatch.countDown();
                    }
                }
            }));
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }
    /**
     * newFixedThreadPool submit Callable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test3() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < threads; i++) {
//          Runnable 带返回值
            FutureTask<?> futureTask = new FutureTask<>(new Callable<String>() {
                /**
                 * call
                 * @return currentThreadName
                 */
                @Override
                public String call() {
                    return Thread.currentThread().getName();
                }
            });
            executorService.submit(new Thread(futureTask));
            System.out.println(futureTask.get());
        }
        System.out.println("---- end ----");
    }
}

 

 

 

 

 

 

【并发编程】（十九）Callable的实现原理简述
积木成林，聚沙成塔
04-20 3766
文章目录1.Callable概述1.1.Callable与Runable的区别1.2.Callable的使用2.实现原理简述2.1.Callable是如何被线程调度的2.2.返回值的获取2.3.阻塞的实现2.4.阻塞线程的唤醒3.Callble执行流程图 1.Callable概述 1.1.Callable与Runable的区别 Callable是一个用于定义多线程执行的代码逻辑的接口，里面定义了一个call()方法，类似于Runnable中的run()方法。子类实现了Callable接口后就可以重写call
五分钟带你玩转多线程（二）带你了解线程池
小鲍侃java
02-24 678
https://blog.youkuaiyun.com/u013541140/article/details/95225769 https://blog.youkuaiyun.com/z_s_z2016/article/details/81674893 https://blog.youkuaiyun.com/qq_31615049/article/details/80756781
【jeecg-boot项目开发crm】：平台技术点——day05【Java定时任务解决方案：五、定时任务线程池】：图灵课堂
qq_40572023的博客
11-17 958
三、定时任务线程池 图例： 代码演示： 其中定义线程池和执行线程的主类：ScheduleThreadPoolTest，和线程实现类：Task package com.tuling.pool; import java.util.Date; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; impo
JeecgBoot后端并发编程：线程池配置与任务调度
最新发布
gitblog_00982的博客
11-08 396
在企业级应用开发中，后端系统常面临高并发请求处理的挑战。JeecgBoot作为企业级低代码平台，通过合理的线程池配置与任务调度机制，有效提升系统并发处理能力。本文将从线程池配置、异步任务处理、定时任务调度三个维度，详解JeecgBoot的并发编程实践。 ## 线程池配置机制 JeecgBoot基于Spring框架的线程池抽象，提供可配置化的任务执行器。核心配置类通过`@Bean`注解声明线程池
Callable线程池工具类
weixin_43939924的博客
11-23 369
import lombok.AllArgsConstructor; import lombok.NoArgsConstructor; import java.util.concurrent.Callable; import java.util.function.Function; /** * 多线程 * T: 线程处理的参数 * R: 线程处理结果 * * @author: Qz1997 * @create 2021/11/22 14:04 */ @NoArgsConstructor @A
自定义线程池
祁_z
06-11 403
手写线程池 /** * 流程： * 1. 成员变量： * 初始化线程数量; * 链表堵塞队列; * 结束线程池标识; * 2. 创建有参构造方法初始化线程数量，并调用“线程任.
你没机会可以见面
vx15323791157的博客
11-04 127
发货人发过
精选资源
多线程与线程池技术详解
06-12
在Java编程领域，多线程和线程池技术是核心且关键的概念，它们在现代的高性能、高并发应用中扮演着重要角色。多线程允许应用程序同时执行多个任务，而线程池则是一种管理和控制线程的有效手段，有助于提高系统的效率...
精选资源
常用多线程模板与鱼刺类多线程线程池应用小例子
06-06
本篇文章将详细探讨“常用多线程模板”以及“鱼刺类（Fork/Join框架）多线程线程池”的应用，结合具体的代码实例来帮助理解这些概念。 首先，多线程是指在一个程序中同时执行多个不同的线程，以实现并行处理。在...
线程池管理多线程上传
01-15
线程池管理和多线程上传是并发编程中的一个重要实践，特别是在大数据传输和网络服务中。在Java等编程语言中，线程池通过有效地管理和复用线程资源，避免了频繁创建和销毁线程带来的开销，提升了系统性能。下面将详细...
精选资源
Android多线程：完全解析线程池ThreadPool原理&使用
02-25
1.对于多线程，大家应该很熟悉。但是，大家了解线程池吗？2.今天，我将带大家全部学习关于线程池的所有知识。线程池中有6个核心参数，具体如下上述6个参数的配置决定了线程池的功能，具体设置时机=创建线程池类对象...
精选资源
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
websocket消息实时推送
08-22
做的一个简单的小案例，websocket实时推送消息，当执行一个操作后可以通知页面刷新
线程池的简单实战使用(对图片的一些处理)
牧xin的博客
01-23 558
目前的业务,由于图片过大,前端需要缩略图,上传后,后端进行图片压缩,但是一般压缩的效率都较为低,所以再开一个线程进行图片的压缩,删除等的处理
Callable的使用和自定义自己的Callable接口
chenjianhuideyueding的博客
07-12 725
Callable对比Runnale接口来说，可以返回线程执行的结果： public static void main(String[] args) throws Exception { FutureTask future = new FutureTask(() -> { TimeUnit.SECONDS.sleep(10); return "hello"; }); new Thread(future
多线程之callable详解
热门推荐
qq_844085127的博客
09-30 6万+
多线程之callable详解 面试有人会问：线程的实现方式有几种？ 很多人可能回答：2种，继承Thread类，实现Runnable接口。 很多忽略了callable这种方式。 也许有人知道callable，也知道callable和Runnable的区别是callable可以有返回值，也可以抛出异常的特性，而Runnable没有。 那么再问callable和Runnable有什么联系呢？ 这里估计很多人懵逼，接下来我们就从源码层次讲解这个问题。 注意callable可以有返回值，也可以抛出异常这点很关键。 很
代码里面加入线程池，让其执行特定的代码。
weixin_60415789的博客
12-21 538
线程池 线程执行固定的代码
开发中常用多线程异步操作场景解决方案
zhiqiang_zhao
03-21 1548
第一步:创建现场池，注意不同业务场景线程池队列等参数不一样，根据实际业务场景来第二步:团队批量预登记使用如下(当前场景比较复杂，适用于大批量数据并且事务控制是按照部分回滚的；比如100条中有三条错误那么只回滚这三条的数据)第三步：批量发布申请单和批量预登记是一个场景，只不过当前的没有上面那个复杂，数据量不是很多。
Runnable和Callable的区别
weixin_46114677的博客
09-27 193
Future 父类 –FutureTask 子类 Callable –可以代替Runnable,提供更丰富的功能 –有返回值 –可以使用泛型指定返回值类型 –可以抛出异常 Runnable Future future = pool.submit(Runnable) 继续执行当前线程的功能 future.get(); //阻塞,等待任务结束,返回null 当前线程继续处理 public class TestFutura { public static void main(String[] args)
C++多线程与线程池实战案例解析
在线程池的资料汇总中，开发者可以找到多种多线程和线程池的介绍文档、教程和开源代码。这些资料通常会包括： - **多线程编程基础**：包括线程的创建、同步、通信等基础知识。 - **线程池的设计和实现**：如何设计一...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

网寻星

打赏老板，留下需求，为你而码

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值