高并发编程-自定义简易的线程池(1),体会原理

简介: 高并发编程-自定义简易的线程池(1),体会原理

20191031000734676.png

概述


我们工作中,并发编程必然离不开jdk提供的j.u.c中的线程池 ,假设让我们自己去设计一个线程池,该从哪几个方面来着手考虑呢?


首先: 既然是线程池 , 那必然 有个初始化的线程数量 和 最大数量 ----> 两个属性 : init 和 max


其次:当线程池中的线程达到了 init 数量,但还没到max 数量的时候,将任务放入任务队列中,而不是直接开辟新的线程,是不是一种更好的设计? 所以 引入 任务队列,存放任务


最后:当线程池中的线程 把 任务队列也塞满了,也达到了Max的值,新的线程过来,我们改如何处理呢? 是不是指定拒绝策略更合适呢? 比如 直接拒绝,抛出异常,放入临时队列等等。所以 拒绝策略也是需要的


总结一下


  1. init (coreSize) / max , 线程池初始化大小和最大线程数
  2. 任务队列
  3. 拒绝策略
  4. 。。。


示例

逐步实现该需求, 先把基本的流程调通,这里我们先实现定义线程池数量的功能 ,代码如下

package com.artisan.test;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;
public class SimpleThreadPool {
    // 线程数
    private int size;
    // 默认线程数
    private static int DEFAULT_SIZE = 10;
    // 任务队列
    private final static LinkedList<Runnable> TASK_QUEUE = new LinkedList();
    // 工作线程集合
    private final static List<WorkTask> THREAD_QUEUE = new ArrayList<>();
    private static volatile int seq = 0;
    private static final ThreadGroup GROUP = new ThreadGroup("Pool_Group");
    private static final String THREAD_PREFIX = "SIMPLE_THREAD_POOL-";
    /**
     * 默认构造函数
     * 默认10个线程
     */
    public SimpleThreadPool() {
        this(DEFAULT_SIZE);
    }
    /**
     * 线程池中的线程数量
     *
     * @param size
     */
    public SimpleThreadPool(int size) {
        this.size = size;
        // 初始化
        init();
    }
    /**
     * 初始化
     */
    private void init() {
        for (int i = 0; i < size; i++) {
            createWorkTask();
        }
    }
    /**
     * 创建工作线程
     */
    private void createWorkTask() {
        // 创建工作线程
        WorkTask workTask = new WorkTask(GROUP, THREAD_PREFIX + (seq++));
        // 启动
        workTask.start();
        // 加入到工作线程集合
        THREAD_QUEUE.add(workTask);
    }
    /**
     * 将任务runnable 提交到 TASK_QUEUE
     *
     * @param runnable
     */
    public void submit(Runnable runnable) {
        synchronized (TASK_QUEUE) {
            // 添加到队列的最后面
            TASK_QUEUE.addLast(runnable);
            // 唤醒所有正在等待的线程
            TASK_QUEUE.notifyAll();
        }
    }
    /**
     * 线程状态
     */
    enum TaskState {
        FREE,
        RUNNING,
        BLOCKED,
        DEAD
    }
    /**
     * private 私有类
     * 继承Thread 的 工作线程
     */
    private static class WorkTask extends Thread {
        // 默认状态  FREE
        private volatile TaskState state = TaskState.FREE;
        public WorkTask(ThreadGroup threadGroup, String name) {
            super(threadGroup, name);
        }
        /**
         * 获取线程状态
         *
         * @return
         */
        public TaskState getTaskState() {
            return this.state;
        }
        /**
         * 重写run方法
         */
        @Override
        public void run() {
            // 跳出while的标识
            OUTER:
            // 只要不是DEAD 状态,一直从队列中获取消息
            while (state != TaskState.DEAD) {
                Runnable runnable;
                // 对队列进行加锁操作
                synchronized (TASK_QUEUE) {
                    // 如果队列为空,wait
                    while (TASK_QUEUE.isEmpty()) {
                        try {
                            // 更改状态
                            state = TaskState.BLOCKED;
                            // wait 放弃该锁
                            TASK_QUEUE.wait();
                        } catch (InterruptedException e) {
                            // 如果有个线程在wait,终止该线程会被InterruptedException异常捕获,
                            // break OUTER 跳出while循环,从而达到终止这个线程
                            break OUTER;
                        }
                    }
                    // TASK_QUEUE不为空 从队列中获取一个Runnable对象
                    // Removes and returns the first element from this list
                    runnable = TASK_QUEUE.removeFirst();
                }
                if (runnable != null) {
                    // 运行状态
                    state = TaskState.RUNNING;
                    // 运行
                    runnable.run();
                    // 运行结束后 置为FREE
                    state = TaskState.FREE;
                }
            }
        }
        /**
         * 关闭线程
         */
        public void close() {
            this.state = TaskState.DEAD;
        }
    }
    /**
     * 测试
     *
     * @param args
     */
    public static void main(String[] args) {
        SimpleThreadPool simpleThreadPool = new SimpleThreadPool();
//        for (int i = 0; i < 50; i++) {
//            simpleThreadPool.submit(()->{
//                try {
//                    System.out.println(Thread.currentThread().getName() + " is running" );
//                    Thread.sleep(1_000);
//                    System.out.println(Thread.currentThread().getName() + " finished" );
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            });
//        }
        IntStream.range(0, 50)
                .forEach(i ->
                        simpleThreadPool.submit(() -> {
                            try {
                                System.out.println(Thread.currentThread().getName() +  "____" + i +  " start");
                                Thread.sleep(1_000);
                                System.out.println(Thread.currentThread().getName() + "____" + i +" finished");
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }));
    }
}


运行:

SIMPLE_THREAD_POOL-9____0 start
SIMPLE_THREAD_POOL-4____5 start
SIMPLE_THREAD_POOL-0____9 start
SIMPLE_THREAD_POOL-5____4 start
SIMPLE_THREAD_POOL-6____3 start
SIMPLE_THREAD_POOL-8____1 start
SIMPLE_THREAD_POOL-7____2 start
SIMPLE_THREAD_POOL-1____8 start
SIMPLE_THREAD_POOL-3____6 start
SIMPLE_THREAD_POOL-2____7 start
SIMPLE_THREAD_POOL-4____5 finished
SIMPLE_THREAD_POOL-6____3 finished
SIMPLE_THREAD_POOL-5____4 finished
SIMPLE_THREAD_POOL-3____6 finished
SIMPLE_THREAD_POOL-0____9 finished
SIMPLE_THREAD_POOL-9____0 finished
SIMPLE_THREAD_POOL-0____13 start
SIMPLE_THREAD_POOL-2____7 finished
SIMPLE_THREAD_POOL-5____12 start
SIMPLE_THREAD_POOL-1____8 finished
SIMPLE_THREAD_POOL-6____11 start
SIMPLE_THREAD_POOL-7____2 finished
SIMPLE_THREAD_POOL-4____10 start
SIMPLE_THREAD_POOL-8____1 finished
SIMPLE_THREAD_POOL-7____17 start
SIMPLE_THREAD_POOL-1____16 start
SIMPLE_THREAD_POOL-2____15 start
SIMPLE_THREAD_POOL-9____14 start
SIMPLE_THREAD_POOL-8____18 start
SIMPLE_THREAD_POOL-3____19 start
SIMPLE_THREAD_POOL-0____13 finished
SIMPLE_THREAD_POOL-0____20 start
SIMPLE_THREAD_POOL-5____12 finished
SIMPLE_THREAD_POOL-5____21 start
SIMPLE_THREAD_POOL-6____11 finished
SIMPLE_THREAD_POOL-6____22 start
SIMPLE_THREAD_POOL-4____10 finished
SIMPLE_THREAD_POOL-4____23 start
SIMPLE_THREAD_POOL-7____17 finished
SIMPLE_THREAD_POOL-7____24 start
SIMPLE_THREAD_POOL-1____16 finished
SIMPLE_THREAD_POOL-1____25 start
SIMPLE_THREAD_POOL-2____15 finished
SIMPLE_THREAD_POOL-2____26 start
SIMPLE_THREAD_POOL-9____14 finished
SIMPLE_THREAD_POOL-9____27 start
SIMPLE_THREAD_POOL-8____18 finished
SIMPLE_THREAD_POOL-8____28 start
SIMPLE_THREAD_POOL-3____19 finished
SIMPLE_THREAD_POOL-3____29 start
SIMPLE_THREAD_POOL-5____21 finished
SIMPLE_THREAD_POOL-2____26 finished
SIMPLE_THREAD_POOL-1____25 finished
SIMPLE_THREAD_POOL-7____24 finished
SIMPLE_THREAD_POOL-4____23 finished
SIMPLE_THREAD_POOL-0____20 finished
SIMPLE_THREAD_POOL-6____22 finished
SIMPLE_THREAD_POOL-0____35 start
SIMPLE_THREAD_POOL-4____34 start
SIMPLE_THREAD_POOL-7____33 start
SIMPLE_THREAD_POOL-1____32 start
SIMPLE_THREAD_POOL-8____28 finished
SIMPLE_THREAD_POOL-3____29 finished
SIMPLE_THREAD_POOL-2____31 start
SIMPLE_THREAD_POOL-9____27 finished
SIMPLE_THREAD_POOL-5____30 start
SIMPLE_THREAD_POOL-9____39 start
SIMPLE_THREAD_POOL-3____38 start
SIMPLE_THREAD_POOL-8____37 start
SIMPLE_THREAD_POOL-6____36 start
SIMPLE_THREAD_POOL-8____37 finished
SIMPLE_THREAD_POOL-2____31 finished
SIMPLE_THREAD_POOL-5____30 finished
SIMPLE_THREAD_POOL-3____38 finished
SIMPLE_THREAD_POOL-9____39 finished
SIMPLE_THREAD_POOL-6____36 finished
SIMPLE_THREAD_POOL-9____44 start
SIMPLE_THREAD_POOL-0____35 finished
SIMPLE_THREAD_POOL-4____34 finished
SIMPLE_THREAD_POOL-3____43 start
SIMPLE_THREAD_POOL-4____47 start
SIMPLE_THREAD_POOL-7____33 finished
SIMPLE_THREAD_POOL-7____48 start
SIMPLE_THREAD_POOL-5____42 start
SIMPLE_THREAD_POOL-1____32 finished
SIMPLE_THREAD_POOL-2____41 start
SIMPLE_THREAD_POOL-8____40 start
SIMPLE_THREAD_POOL-1____49 start
SIMPLE_THREAD_POOL-0____46 start
SIMPLE_THREAD_POOL-6____45 start
SIMPLE_THREAD_POOL-3____43 finished
SIMPLE_THREAD_POOL-5____42 finished
SIMPLE_THREAD_POOL-7____48 finished
SIMPLE_THREAD_POOL-4____47 finished
SIMPLE_THREAD_POOL-9____44 finished
SIMPLE_THREAD_POOL-6____45 finished
SIMPLE_THREAD_POOL-0____46 finished
SIMPLE_THREAD_POOL-1____49 finished
SIMPLE_THREAD_POOL-8____40 finished
SIMPLE_THREAD_POOL-2____41 finished


可知: 虽然定义了50个任务,但是根据日志来看,是由10个线程来完成的,符合预期。


相关文章
|
1天前
|
数据采集 存储 数据处理
Python中的多线程编程及其在数据处理中的应用
本文深入探讨了Python中多线程编程的概念、原理和实现方法,并详细介绍了其在数据处理领域的应用。通过对比单线程与多线程的性能差异,展示了多线程编程在提升程序运行效率方面的显著优势。文章还提供了实际案例,帮助读者更好地理解和掌握多线程编程技术。
|
5天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
14天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
11天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
14天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
14天前
|
安全 Java 编译器
Java多线程编程的陷阱与最佳实践####
【10月更文挑战第29天】 本文深入探讨了Java多线程编程中的常见陷阱,如竞态条件、死锁、内存一致性错误等,并通过实例分析揭示了这些陷阱的成因。同时,文章也分享了一系列最佳实践,包括使用volatile关键字、原子类、线程安全集合以及并发框架(如java.util.concurrent包下的工具类),帮助开发者有效避免多线程编程中的问题,提升应用的稳定性和性能。 ####
42 1
|
18天前
|
存储 设计模式 分布式计算
Java中的多线程编程:并发与并行的深度解析####
在当今软件开发领域,多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制,从基础概念到高级应用,全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述,本文旨在通过详尽的技术剖析,为读者构建一个系统化的多线程知识框架,辅以生动实例,让抽象概念具体化,复杂问题简单化。 ####
|
19天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
44 4
|
19天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域,多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践,通过实际案例分析,帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结,本文将结合作者多年的实践经验,以故事化的方式讲述多线程编程的魅力与挑战,旨在为读者提供一种全新的学习视角。
46 3
|
20天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
32 1
下一篇
无影云桌面