Java多线程使用和原理详解

心之所向-

已于 2022-08-23 17:17:00 修改

阅读量419

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

于 2022-08-23 10:54:29 首次发布

本文链接：https://blog.csdn.net/qq_42217363/article/details/126479895

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.线程池的优点：

2.线程池的实现原理：

2.1 ThreadPoolExecutor执行示意图

1.线程池的优点：
线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。

2.线程池的实现原理：
提交一个任务到线程池中，线程池的处理流程如下：

1> 判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

2> 线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3> 判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

2.1 ThreadPoolExecutor执行示意图

上图说明：

1、如果线程池中的线程数量少于corePoolSize，就创建新的线程来执行新添加的任务
2、如果线程池中的线程数量大于等于corePoolSize，但队列workQueue未满，则将新添加的任务放到workQueue中
3、如果线程池中的线程数量大于等于corePoolSize，且队列workQueue已满，但线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务
4、如果线程池中的线程数量超出了maximumPoolSize，就用RejectedExecutionHandler.rejectedExecution()方法来执行拒绝策略

总结：ThreadPoolExecutor采取上述的总体设计思路，就是为了在执行execute方法时，尽可能地避免获取全局锁，当运行的线程数大于等于corePoolSize时，几乎所有的excute()都会执行步骤2，而步骤2而不需要获取全局锁，步骤3是需要加锁创建的。

源码：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
　　　　　　 //如果线程数大于等于基本线程数或者线程创建失败，将任务加入队列
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
　　　　　　　　　　//线程池处于运行状态并且加入队列成功
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
　　　　　　　　　//线程池不处于运行状态或者加入队列失败，则创建线程（创建的是非核心线程）
            else if (!addIfUnderMaximumPoolSize(command))  //这个方法里面会加锁
　　　　　　　　　　　//创建线程失败，则采取阻塞处理的方式
                reject(command); // is shutdown or saturated
        }
    }
}

3.线程池的使用
我们可以通过ThreadPoolExecutor来创建线程池

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,RejectedExecutionHandler handler);

ThreadPoolExecutor有多个构造器，不一定全部参数都包含，没有包含的使用默认值，以下是参数说明：

　　corePoolSize：核心线程池的线程数量
　　maximumPoolSize：最大的线程池线程数量
　　keepAliveTime：线程活动保持时间，线程池的工作线程空闲后，保持存活的时间，一般都是0
　　unit：线程活动保持时间的单位。

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

workQueue：指定任务队列所使用的阻塞队列,当然不仅仅只有下面三个阻塞队列，有优先级的可以考虑PriorityBlockingQueue，建议使用有界队列，否则后面无界的话不停的创建线程，容易撑爆内存

ArrayBlockingQueue; //基于数组的有界阻塞队列
LinkedBlockingQueue;//基于链表的阻塞队列，此队列吞吐量高于ArrayBlockingQueue，静态工厂Executors.newFixedThreadPool()默认使用的这个队列，默认队列长度是Integer.MAX_VALUE
SynchronousQueue; //一个不会存储元素的阻塞队列，吞吐量高于LinkedBlockQueue,静态工厂Executors.newCachedThreadPool()默认使用的这个队列

ThreadFactory:线程工厂，主要用来创建线程；
handler:当队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进行处理，默认是AbortPolicy，这四个都是ThreadPoolExecutor的静态内部类，这几个类都是是实现RejectedExecutionHandler接口的hanler有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常，这是默认的策略 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用者所在线程处理该任务

我们现在用第四种策略来处理上面的程序例子：

public static void main(String[] args){
        LinkedBlockingQueue<Runnable> queue =
            new LinkedBlockingQueue<Runnable>(3);
        RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();
 
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5, 60, TimeUnit.SECONDS, queue,handler);
        for (int i = 0; i < 9 ; i++){
            threadPool.execute(
                new Thread(new ThreadPoolTest(), "Thread".concat(i + "")));
            System.out.println("线程池中活跃的线程数： " + threadPool.getPoolSize());
            if (queue.size() > 0){
                System.out.println("----------------队列中阻塞的线程数" + queue.size());
            }
        }
        threadPool.shutdown();
    }

执行结果：

线程池中活跃的线程数： 1
线程池中活跃的线程数： 2
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数1
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数2
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 3
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 4
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数3

这里采用了丢弃策略后，就没有再抛出异常，而是直接丢弃。在某些重要的场景下，可以自定义处理策略，采用记录日志或者存储到数据库中，而不应该直接丢弃。

4.向线程池提交任务
有两个方法提交，一个是execute()方法和submit()方法。

差别 execute() submit()

方法定义

在ThreadPoolExecutor中实现，父类

Excutor顶级接口定义的方法execute(),由子类ThreadPoolExecutor最终实现

AbstractExecutorService实现的接口ExecutorService定义这个submit方法，由AbstractExecutorService实现，但是中间还是调用模板方法execute方法。

返回值

用于提交不需要返回值的任务，所以无法判断任务是否被执行成功

方法用于提交需要返回值的任务，线程池返回一个future类型的对象，通过这个future对象你可以判定是否执行成功,可以通过future的get()获取返回值，get()方法会阻塞当前线程，直到完成任务为止，使用get(lont timeout,TimeUnit unit)可以阻塞一定的时间立即返回。这时候线程任务可能没有完成

ThreadPoolExecutor中实现的execute实现的方法见上面所示，接口Exeutor中定义如下：

public interface Executor {
    void execute(Runnable command); //这是这个接口定义的唯一一个方法
}

AbstractExecutorService中的submit方法，有三种重载方法，源码：

public interface Executor {
    void execute(Runnable command); //这是这个接口定义的唯一一个方法
}
 AbstractExecutorService中的submit方法，有三种重载方法，源码：

public abstract class AbstractExecutorService implements ExecutorService {
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
 
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
}

5.关闭线程池
可以通过调用线程池的shutdown或者shutdownNow方法关闭线程池，他们的原理都是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止，两者的差别：

shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或者暂停任务的线程，并返回等待执行任务的列表;
shutdown只是将线程池的状态设置为SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

只要调用了这两个关闭方法的任意一个，isShutDown方法就会返回true，当所有的任务都已经关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true，至于应该调用那一个方法，可以根据线程池的特性来决定，通常用shutdown方法调用关闭线程池，如果任务不一定执行完，则可以调用shutdownNow。

6.线程池提供方法可以重写
这几个是ThreadPoolExecutor提供的未实现的方法，可以通过重写他们在任务执行前，执行后和线程池关闭前执行一些代码来进行监控。

 protected void beforeExecute(Thread t, Runnable r) { }
    protected void afterExecute(Runnable r, Throwable t) { }
    protected void terminated() { }

7.监控线程池，自定义线程池

package com.vison.ws;
 
import java.util.Date;
import java.util.concurrent.*;
 
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
 
    private ConcurrentHashMap<String, Date> startTime = new ConcurrentHashMap<String, Date>(); //记录当时的运行时间
 
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
 
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }
 
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }
 
    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }
 
    //运行之前
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        startTime.put(String.valueOf(r.hashCode()),new Date()); //把当前任务的hashCode作为键存储，值作为当前时间
        super.beforeExecute(t, r);
    }
 
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        //计算任务执行时间
        Date startDate = startTime.remove(String.valueOf(r.hashCode()));
        long timeWaste = new Date().getTime() - startDate.getTime();
        System.out.println("任务耗时："+timeWaste);
        System.out.println("最大线程数："+this.getMaximumPoolSize());
 
        super.afterExecute(r, t);
    }
 
    //关闭的时候
    @Override
    public void shutdown() {
        System.out.println("已经执行的任务数量："+this.getCompletedTaskCount()+"\n");
        System.out.println("当前活动的线程数："+this.getActiveCount()+"\n");
        System.out.println("当前排队的线程数："+this.getQueue().size()+"\n");
        super.shutdown();
    }
 
    //自定义线程池的创建，当然可以通过 自定义线程池工厂，自定义自己的专属的线程名
    public static ExecutorService newMyExecutorService(){
       return new ThreadPoolExecutor(1,2,0L,TimeUnit.MILLISECONDS,new  LinkedBlockingQueue(20));
    }
}

二、线程池Executors和ThreadPoolExecutor区别

一般我们创建线程池的时候，有两种选择，第一种是通过ThreadPoolExecutor创建，还有一种就是通过Executors创建。那么他们区别是什么呢，我们接下来分析：

Executors类和ThreadPoolExecutor都是util.concurrent并发包下面的类， Executos下面的newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor、newCachedThreadPool底线的实现都是用的ThreadPoolExecutor实现的，所以ThreadPoolExecutor更加灵活。

ThreadPoolExecutor

public static ExecutorService exec = new ThreadPoolExecutor(
            1,     //1.核心线程池大小
            5,     //2.最大线程池大小
            1000L, //3.线程最大空闲时间
            TimeUnit.MILLISECONDS, //4.时间单位
            new LinkedBlockingQueue<Runnable>(1024), //5.线程等待队列
            new ThreadFactory() {    //6.线程创建的工厂对象
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r);
                }
            }, 
            new ThreadPoolExecutor.AbortPolicy() //7.拒绝策略,这里直接抛出异常
    );

参数一：corePoolSize ， 核心线程数，线程池的最小线程数量     核心线程数线程数定义了最小可以同时运行的线程数量。
参数二：maximumPoolSize，最大线程数，如果线程池的线程不够用时，会创建新的线程，但是不会超过这个数量
参数三：keepAliveTime，线程最大的空闲时间，超过核心线程数的线程，超过空闲时间后，就会被自动回收
参数四：unit，空闲时间的单位
参数五（重要）：workQueue，线程池的阻塞队列对象（类型）新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。
参数六：threadFactory，线程创建的工厂对象（决定了线程的创建方式）可以对线程进行统一设置，如是否守护线程、线程名等
参数七：handler，多余的任务（Runnable）如果无法放入阻塞队列，该用什么方式拒绝该任务（4种方式）线程数量达到maximumPoolSize时的策略，默认提供了4种：AbortPolicy: 直接丢弃并抛出异常CallerRunsPolicy: 线程池没有关闭则直接调用线程的run方法DiscardPolicy: 直接丢弃任务DiscardOldestPolicy: 丢弃最早的任务，并尝试把当前任务加入队列

Executors

线程池通过Executors类的四种创建方式

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

一、newCachedThreadPool：由参数可以看出，核心线程数为0，最大线程数很大，队列为无界阻塞队列，空闲存活时间为60秒，意思就是说，来个任务，如果没有空闲的线程，就创建个线程，如果有空闲的线程，就要空闲的线程。

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

二、newFixedThreadPool：由参数可以看出，这是创建一个固定大小的线程池，核心线程数和最大线程数一致，LinkedBlockingQueue为无界阻塞队列，意思就是说我最多只能创建固定大小的线程来处理任务，比如核心线程数和最大线程数都为7,但突然来了12个任务，另外5个无法立刻执行，就放到了LinkedBlockingQueue中，如果内存无限大，任务可以是无限多的，newFixedThreadPool中的keepAliveTime、unit都是无意思的，原因最大线程数没有超过核心线程数。

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

三、newScheduledThreadPool：由参数可以看出，核心线程数一定，最大线程数很大，队列为优先级队列此线程池可以做定时执行。

 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

三、newSingleThreadExecutor：由参数可以看出，核心线程数和最大线程数都是1，LinkedBlockingQueue为无界阻塞队列，也就是说是中只有一个线程在执行，来了再多个任务都得等，等线程执行完上个任务，再去执行下个任务。

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

自定义ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,//核心线程数
                              int maximumPoolSize,//最大线程数
                              long keepAliveTime,//空闲存活时间
                              TimeUnit unit,//单位
                              BlockingQueue<Runnable> workQueue,//队列
                              RejectedExecutionHandler handler) {//拒绝策略
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

有界队列：根据上面参数可知，当队列为有界队列时，

corePoolSize < maximumPoolSize ，BlockingQueue满了，线程池会创建新的线程，直到maximumPoolSize 也满了，如果超过maximumPoolSize就会触发 RejectedExecutionHandler 拒绝策略，一般是CallerRunsPolicy（只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。）策略，或是自定义自己的拒绝策略，自定义拒绝策略实现RejectedExecutionHandler接口，重写rejectedExecution方法。

corePoolSize < maximumPoolSize ，BlockingQueue满了，线程池会创建新的线程，直到maximumPoolSize 没满，没有触发拒绝策略，过了一段时间，任务减少了，一些线程空闲时间超过了keepAliveTime，就会被移除。

corePoolSize = maximumPoolSize ，BlockingQueue满了，如果超过maximumPoolSize就会触发 RejectedExecutionHandler 拒绝策略。

无界队列：

corePoolSize < maximumPoolSize，队列一直不会满（理想情况下），不会触发拒绝策略，如果一段时间没有任务时线程闲置时间超过keepAliveTime，会被移除线程池。

corePoolSize = maximumPoolSize，队列一直不会满（理想情况下），不会触发拒绝策略，如果一段时间没有任务时线程闲置时间超过keepAliveTime，不会被移除线程池。

心之所向-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程使用和原理详解

Java多线程使用和原理详解。1.线程池的优点：线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。
复制链接

扫一扫