单例线程池 Java 版

最新推荐文章于 2024-08-21 17:38:46 发布
最新推荐文章于 2024-08-21 17:38:46 发布
阅读量2.8k 收藏 4
点赞数
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24143469/article/details/89235614
版权
  1. 线程池：什么是线程池？
    线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程（提高线程复用，减少性能开销）。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中然后等待下一次分配任务。
  2. 为什么要使用线程池？
    1. 线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。
    2. 线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。
    3. 线程池根据当前在系统中运行的进程来优化线程时间片。
    4. 线程池允许我们开启多个任务而不用为每个线程设置属性。
    5. 线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。
    6. 线程池可以用来解决处理一个特定请求最大线程数量限制问题。
  3. 线程池流程分析
    线程池处理流程
    1. 首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
    2. 其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
    3. 最后线程池判断整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。
  4. 代码：
    1. 带有返回值的多线程例子。
单例线程池
package xiancheng;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: kevin
 * @Date: 2019-04-11 13:15
 */
public class ThreadPool {
    /**
     * // 构造一个任务池  
     * 参数说明：  
     * corePoolSize - 池中所保存的线程数，包括空闲线程。  
     * maximumPoolSize - 池中允许的最大线程数。  
     * keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。  
     * unit - keepAliveTime 参数的时间单位。  
     * workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。  
     * threadFactory - 执行程序创建新线程时使用的工厂。  
     * handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序
     */
    private ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));
    private static ThreadPool instance = null;

    private ThreadPool(){
    }

    /**
     * 使用线程执行任务
     * @param runnable
     */
    public void executor(Runnable runnable) {
        executor.execute(runnable);
    }

    /**
     * 关闭线程池
     */
    public void shutdown() {
        executor.shutdown();
    }

    /**
     * 获取单例的线程池对象：双锁检查实现单例线程池
     * @return
     */
    public static ThreadPool getThreadPool() {
        if (instance == null) {
            synchronized (ThreadPool.class) {
                if (instance == null) {
                    instance = new ThreadPool();
                }
            }
        }
        return instance;
    }
}

处理任务Integer
package xiancheng.test;

import org.apache.commons.compress.utils.Lists;

import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @Author: kevin
 * @Date: 2019-04-12 09:57
 */
public class GetThreadInteger implements Runnable {
    AtomicReference<List<Integer>> resultInteger = new AtomicReference<>();

    @Override
    public void run() {
        resultInteger.set(getIntegers());
    }

    public static List<Integer> getIntegers() {
        List<Integer> list = Lists.newArrayList();
        for (int i = 100; i < 200; i++) {
            System.out.println(Thread.currentThread().getName() + "=====" + i);
            list.add(i);
        }
        return list;
    }
}

String
package xiancheng.test;

import org.apache.commons.compress.utils.Lists;

import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @Author: kevin
 * @Date: 2019-04-12 09:57
 */
public class GetThreadString implements Runnable {
    AtomicReference<List<String>> resultString = new AtomicReference<>();
    @Override
    public void run() {
        resultString.set(getStrings());
    }

    public List<String> getStrings() {
        List<String> list = Lists.newArrayList();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "=====" + i);
            list.add(String.valueOf(i));
        }
        return list;
    }
}

测试类：
package xiancheng.test;

import xiancheng.ThreadPool;

import java.util.List;
import java.util.concurrent.FutureTask;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @Author: kevin
 * @Date: 2019-04-12 09:31
 */
public class TestThread {
    public static void main(String[] args) {
        AtomicReference<List<String>> resultString = new AtomicReference<>();
        AtomicReference<List<Integer>> resultInteger = new AtomicReference<>();

        ThreadPool threadPool = ThreadPool.getThreadPool();

        try {
            /**
             * 无返回值的多线程
             */
            threadPool.executor(new GetThreadString());
            threadPool.executor(new GetThreadInteger());
            for (int i = 0; i < 100; i++) {
                System.out.println("========--------" + Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

        System.out.println(resultInteger.get().size());
        System.out.println(resultString.get().size());
    }
}

处理任务String：
package xiancheng.test;

import org.apache.commons.compress.utils.Lists;

import java.util.List;
import java.util.concurrent.Callable;

/**
 * @Author: kevin
 * @Date: 2019-04-12 13:20
 */
public class GetThreadStringReturn implements Callable<List<String>> {
    @Override
    public List<String> call() throws Exception {
        List<String> list = Lists.newArrayList();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "=====" + i);
            list.add(String.valueOf(i));
        }
        return list;
    }
}

Integer：
package xiancheng.test;

import org.apache.commons.compress.utils.Lists;

import java.util.List;
import java.util.concurrent.Callable;

/**
 * @Author: kevin
 * @Date: 2019-04-12 13:20
 */
public class GetThreadIntegerReturn implements Callable<List<Integer>> {
    @Override
    public List<Integer> call() throws Exception {
        List<Integer> list = Lists.newArrayList();
        for (int i = 100; i < 200; i++) {
            System.out.println(Thread.currentThread().getName() + "=====" + i);
            list.add(i);
        }
        return list;
    }
}

测试类：
package xiancheng.test;

import xiancheng.ThreadPool;

import java.util.List;
import java.util.concurrent.FutureTask;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @Author: kevin
 * @Date: 2019-04-12 09:31
 */
public class TestThread {
    public static void main(String[] args) {
        AtomicReference<List<String>> resultString = new AtomicReference<>();
        AtomicReference<List<Integer>> resultInteger = new AtomicReference<>();

        ThreadPool threadPool = ThreadPool.getThreadPool();

        try {
        	 /**
             * 有返回值的多线程
             */
            FutureTask<List<String>> listStringFutureTask = new FutureTask(new GetThreadStringReturn());
            FutureTask<List<Integer>> listIntegerFutureTask = new FutureTask(new GetThreadIntegerReturn());
            threadPool.executor(listStringFutureTask);
            threadPool.executor(listIntegerFutureTask);

            resultString.set(listStringFutureTask.get());
            resultInteger.set(listIntegerFutureTask.get());

            for (int i = 0; i < 100; i++) {
                System.out.println("========--------" + Thread.currentThread().getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
        System.out.println(resultInteger.get().size());
        System.out.println(resultString.get().size());
    }
}
  1. 线程池的监控
    taskCount：线程池需要执行的任务数量。
    completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。
    largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
    getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。
    getActiveCount：获取活动的线程数。

菜鸟一个，如有不对，欢迎指出。。。。

无极侠岚
关注
专栏目录
线程池的好处，详解，单例（绝对好记）
fengye454545的博客
03-13 4万+
      转载请注意出处：http://blog.csdn.net/fengye454545/article/details/79536986      前几天公司面试，问了很多线程池的问题，由于也是菜鸟一只本来对线程池就不太熟悉，再加上一紧张脑袋一紧，就GG了，之后可谓是深恶痛极，决定把线程池这边好好的整理一番。一、线程池的好处        线程池是啥子，干啥使它呀，老子线程使得好好的，非得...
java单例线程池，管理线程池的创建和使用
沉浮yu大海的博客
03-13 913
枚举类实现了线程池的单例模式。通过使用单例模式，可以确保整个应用程序只有一个线程池实例，方便统一管理和控制线程池的行为。在这份Java代码中，通过。
FixedThreadPool线程池的单例实现
03-13
内含线程池的单例的详细过程，对线程池的学习有着重要参考价值
java 线程池单例_java中常见的6种线程池示例详解
weixin_31008279的博客
02-12 1032
之前我们介绍了线程池的四种拒绝策略，了解了线程池参数的含义，那么今天我们来聊聊Java 中常见的几种线程池，以及在jdk7 加入的 ForkJoin 新型线程池首先我们列出Java 中的六种线程池如下线程池名称描述FixedThreadPool核心线程数与最大线程数相同SingleThreadExecutor一个线程的线程池CachedThreadPool核心线程为0，最大线程数为Integer....
多线程（4）——单例模式、阻塞队列、线程池、定时器
最新发布
Yuan_o_的博客
08-21 1238
单例模式、饿汉模式、懒汉模式、阻塞队列(BlockingQueue)、生产者消费者模型、线程池(ExecutorService、shutdown())、定时器(Timer、TimerTask)
单例线程池
霸王龙i的博客
06-30 203
package com.yhcookie; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * 线程池 * @author yhcookie * @date 2021/4/23 18:37 */ public class SingleThreadPoolExecutor extends ThreadPoolExecutor { private volatile st
java 单例多线程 线程池_Java并发编程入门
weixin_39944375的博客
02-26 50
线程池上一个程序中使用到了线程池。我们知道，进程的创建的杀死都需要耗费一定的资源，采用线程就是因为线程耗费的资源较少，然而线程在创建和杀死的时候也同样会耗费资源，特别是在程序中需要平凡的这么做的时候，会浪费大量的资源。最形象的例子就是数据库的连接池，在连接数据库的时候设置了连接池用来节约和控制资源。我们在来看一下刚刚的程序有关于线程池的关键部分：ExecutorService executorSe...
ThreadPoolExecutor 创建单例线程池 java
08-01
回答: 在Java中，可以使用ThreadPoolExecutor类来创建单例线程池。在引用[1]中的示例代码中，通过静态内部类SingletonHolder来创建线程池实例，使用了自定义的线程池参数，包括核心线程数、最大线程数、超时等待时间...
使用ThreadPoolExecutor创建单例线程池 java
08-01
使用ThreadPoolExecutor创建单例线程池的方法可以参考引用[2]中的代码。在这个例子中，通过静态内部类的方式创建了一个SingletonHolder类，该类中包含了一个ExecutorService类型的threadPool变量，用于存储线程池...
关于Java线程池-单例模式线程池的操作说明
大雷
10-28 715
背景 项目应用后期特此纪要！ 问题 Java单例模式线程池的工作原理是什么？ 说明 文章主要以简明扼要的用例来说明问题，动手为主！ 纪要 下面是随笔的几篇用例，来说明关于Java单例模式线程池的工作原理。用例如下： public static void main(String[] args) { /** * 用例1 * 首先，第一个用例创建一个单例线程池，从结果可以看出他貌似是按序进行执行。为了确认...
Java 线程池详解及创建简单实例
08-31
Java线程池是一种高效管理并发任务的机制，它通过复用已存在的线程来减少线程创建和销毁的开销，从而提高系统的整体性能。本文将深入解析Java线程池的工作原理，并给出创建简单实例的步骤。 线程池的核心在于`java....
java 线程池单例_线程池的单例实现
weixin_28730353的博客
02-12 798
懒汉式importjava.util.concurrent.Executors;importjava.util.concurrent.LinkedBlockingDeque;importjava.util.concurrent.ThreadPoolExecutor;importjava.util.concurrent.TimeUnit;public classThreadPoolService {...
java ThreadPoolExecutor 单例线程池
spjhandsomeman的专栏
09-24 776
java ThreadPoolExecutor 单例线程池。
线程池的单例构造与使用
Carson的专栏
05-29 1554
1.做一个线程池的工具类（最简单的）package cn.xdf.wlyy.thread; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class Thre...
java 单例线程池配置_java(线程池的创建方式,和线程池的原理)
weixin_39633276的博客
02-16 432
1.为什么要使用线程池：减少资源消耗,通过重复的使用已创建好的线程，避免了线程的频繁创建和销毁所造成的消耗提高响应速度,当任务到达的时候，不需要再去创建，可以直接使用已经创建好的线程就能立即执行任务提高线程的管理性,线程池可以统一管理线程的创建，销毁，分配，调优监控2.使用线程池能解决什么问题通过固定的几个线程为大量的操作服务,降低线程的频繁创建,销毁线程所需要消耗的时间，从而提高效应效率3.线程...
java 单例多线程 线程池_Java 多线程系列1——浅聊JAVA 线程池的一般用法
weixin_39747334的博客
02-26 179
一、为什么要用线程池1)、降低资源消耗，通过重复利用已创建的线程降低线程的创建和销毁造成的消耗。2)、提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。3)、提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。二、注意1)、需要对线程池原理了如指掌。三、线程的常见用法1)、New Thread。...
java线程池使用单例模式
喵酱
02-01 1823
java线程池使用单例模式
java 单例线程池配置_线程池的单例构造与使用
weixin_33216916的博客
02-16 229
1.做一个线程池的工具类(最简单的)package cn.xdf.wlyy.thread;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class ThreadPool ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值