关于线程池,那些你还不知道的事

Posted tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了关于线程池,那些你还不知道的事相关的知识,希望对你有一定的参考价值。

一、背景

  最近在学习线程相关的知识,然后顺理成章少不了学习线程池,刚开始在没有深入的学习之前,感觉线程池是很神秘的东西,而且完全想不到怎么才能实现一个自己的线程池,然后还能保证它的可用性,然后就一直琢磨,琢磨了一周才不多,也是网上各种查资料,终于明白了线程池的原理,也自己手写一个线程池,来加深印象,那么本文我们就来聊一聊关于线程池的知识,希望更多的猿友能看到,从此对线程池有一个清晰直观的认识。

二、概念解析

1.什么是线程池

  线程池的基本思想是一种对象池,在程序启动时就开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。

2.使用线程池的好处

  合理的使用线程池可以重复利用已创建的线程,这样就可以减少在创建线程和销毁线程上花费的时间和资源。并且,线程池在某些情况下还能动态的调整工作线程的数量,以平衡资源消耗和工作效率。同时线程池还提供了对池中工作线程进行统一的管理的相关方法。这样就相当于我们一次创建,就可以多次使用,大量的节省了系统频繁的创建和销毁线程所需要的资源。

3.线程池的主要组件

一个线程池包括以下四个基本组成部分:
(1)、线程池管理器(ThreadPool):用于创建并管理线程池,包括 创建线程池,销毁线程池,添加新任务;
(2)、工作线程(WorkThread):线程池中线程,在没有任务时处于等待状态,可以循环的执行任务;
(3)、任务接口(Task):每个任务必须实现的接口,以供工作线程调度任务的执行,它主要规定了任务的入口,任务执行完后的收尾工作,任务的执行状态等;
(4)、任务队列(taskQueue):用于存放没有处理的任务。提供一种缓冲机制。

4.JDK中线程池常用类UML类关系图

三、手写实现

我们知道了线程池的原理以及主要组件之后,就让我们来手动实现一个自己的线程池,以加深理解和深入学习。

1.线程池接口类

package com.hafiz.proxy.threadPool;

import java.util.List;

/**
 * Desc:线程池接口类
 * Created by hafiz.zhang on 2017/9/19.
 */
public interface ThreadPool {

    // 执行单个线程任务
    void execute(Runnable task);

    // 执行多个任务
    void execute(Runnable[] tasks);

    // 执行多个任务
    void execute(List<Runnable> tasks);

    // 返回已经执行的任务个数
    int getExecuteTaskNumber();

    // 返回等待被处理的任务个数,队列的长度
    int getWaitTaskNumber();

    // 返回正在工作的线程的个数
    int getWorkThreadNumber();

    // 关闭线程池
    void destroy();
}

2.线程池实现类ThreadPoolManager.java

package com.hafiz.proxy.threadPool;

import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Desc:线程池实现类
 * Created by hafiz.zhang on 2017/9/19.
 */
public class ThreadPoolManager implements ThreadPool {

    // 线程池中默认线程的个数为5
    private static Integer workerNum = 5;

    // 工作线程数组
    WorkThread[] workThreads;

    // 正在执行的线程任务数量
    private static volatile Integer executeTaskNumber = 0;

    // 任务队列, 作为一个缓冲
    private Queue<Runnable> taskQueue = new ConcurrentLinkedQueue<>();

    // 单例模式
    private static ThreadPoolManager threadPool;

    private AtomicLong threadNum = new AtomicLong();

    private ThreadPoolManager() {
        this(ThreadPoolManager.workerNum);
    }

    private ThreadPoolManager(int workerNum) {
        if (workerNum > 0) {
            ThreadPoolManager.workerNum = workerNum;
        }
        workThreads = new WorkThread[ThreadPoolManager.workerNum];
        for (int i = 0; i < ThreadPoolManager.workerNum; i++) {
            workThreads[i] = new WorkThread();
            Thread thread = new Thread(workThreads[i], "ThreadPool-worker-" + threadNum.incrementAndGet());
            thread.start();
            System.out.println("初始化线程总数:" + (i+1) + ",当前线程名称是:ThreadPool-worker-" + threadNum);
        }
    }

    public static ThreadPool getThreadPool() {
        return getThreadPool(workerNum);
    }

    public static ThreadPool getThreadPool(int workerNum) {
        if (workerNum > 0) {
            ThreadPoolManager.workerNum = workerNum;
        }
        if (threadPool == null) {
            threadPool = new ThreadPoolManager(ThreadPoolManager.workerNum);
        }
        return threadPool;
    }


    @Override
    public void execute(Runnable task) {
        synchronized (taskQueue) {
            taskQueue.add(task);
            taskQueue.notifyAll();
        }
    }

    @Override
    public void execute(Runnable[] tasks) {
        execute(Arrays.asList(tasks));
    }

    @Override
    public void execute(List<Runnable> tasks) {
        synchronized (taskQueue) {
            for (Runnable task : tasks) {
                 taskQueue.add(task);
            }
            taskQueue.notifyAll();
        }
    }

    @Override
    public String toString() {
        return "ThreadPoolManager{" +
                "当前的工作线程数量=" + getWorkThreadNumber() +
                ", 已完成的任务数=" + getExecuteTaskNumber() +
                ", 等待任务数=" + getWaitTaskNumber() +
                \'}\';
    }

    @Override
    public int getExecuteTaskNumber() {
        return executeTaskNumber;
    }

    @Override
    public int getWaitTaskNumber() {
        return taskQueue.size();
    }

    @Override
    public int getWorkThreadNumber() {
        return workerNum;
    }

    @Override
    public void destroy() {
        while (!taskQueue.isEmpty()) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int i = 0; i < workThreads.length; i++) {
            workThreads[i].shutdown();
            workThreads[i] = null;
        }
        threadPool = null;
        taskQueue.clear();
    }

    private class WorkThread implements Runnable {
        // 线程是否可用
        private boolean isRunning = true;

        @Override
        public void run() {
            Runnable r = null;
            while (isRunning) {
                // 队列同步机制,加锁
                synchronized (taskQueue) {
                    while (isRunning && taskQueue.isEmpty()) {
                        try {
                            taskQueue.wait(20);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if (!taskQueue.isEmpty()) {
                        r = taskQueue.poll();
                    }
                }
                if (r != null) {
                    r.run();
                }
                executeTaskNumber++ ;
                r = null;
            }
        }

        public void shutdown() {
            isRunning = false;
        }
    }
}

其中该类中包含内部类WorkThread,它用来包装真正的线程类,给每一个线程一个是否可用的标志,该线程工作室同步的从taskQueue中取出要执行的任务进行调用run方法来执行任务。

这个类中的getThreadPool方法中我们还使用到了懒汉式来实现单例,单例模式也是Java常用设计模式之一。

注意该类中的destroy方法的实现:我们是一直等到队列中的所有的任务执行完毕,才真正的销毁线程池,销毁的过程中不要忘记将每一个线程对象置为null,并且清空任务队列,这样更利于java的垃圾回收。

3.自定义任务类Task.java

package com.hafiz.proxy.threadPool;

/**
 * Desc:自定义任务类
 * Created by hafiz.zhang on 2017/9/21.
 */
public class Task implements Runnable {

    private static volatile Integer i = 1;

    @Override
    public void run() {
        // 执行任务
        synchronized (i) {
            System.out.println("当前处理的线程是:" + Thread.currentThread().getName() + ",执行任务:" + (i++) + "完成");
        }
    }
}

4.线程池测试类

package com.hafiz.proxy.threadPool;

import java.util.ArrayList;
import java.util.List;

/**
 * Desc:线程池测试类
 * Created by hafiz.zhang on 2017/9/20.
 */
public class ThreadPoolTest {
    public static void main(String[] args) {
        ThreadPool t = ThreadPoolManager.getThreadPool(6);
        List<Runnable> tasks = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            tasks.add(new Task());
        }
        System.out.println(t);
        t.execute(tasks);
        // 所有的线程执行完成才destroy
        t.destroy();
        System.out.println(t);
    }
}

5.测试结果:(为了篇幅,只创建10个任务运行)

四、总结

  通过本文,我们弄明白线程池到底是怎么工作,学习知识的过程中,我们就是要知其然知其所以然。这样我们才能更好地驾驭它,才能更好地去理解和使用,也能更好地帮助我们触类旁通,后面有机会我们接着来说数据库连接池的原理及手写实现。

以上是关于关于线程池,那些你还不知道的事的主要内容,如果未能解决你的问题,请参考以下文章

数据库和连接池,那些你不可不知道的事

当面试中问到关于多线程安全问题时,你还不知道怎么回答嘛?快点进来,我带你多维度深层次来解决这个问题

看完这篇还不懂线程与线程池你来打我

那些年这么火的MyCat你还不知道吗?

看完这篇还不懂高并发中的线程与线程池你来打我(内含20张图)

Spring功能介绍带你看看那些可能你还不知道的Spring技巧哦!