Java线程池

最新推荐文章于 2023-06-16 14:35:44 发布
最新推荐文章于 2023-06-16 14:35:44 发布
阅读量165 收藏
点赞数
分类专栏： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45025658/article/details/111053275
版权

1、自定义线程池

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w8lWzZQY-1607691573947)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201207182550133.png)]

package com.sharing_model.ThreadPool;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 自定义线程池
 */

public class TestPool {
    public static void main(String[] args) {
        ThreadPool threadPool =
                new ThreadPool(1, 1000,TimeUnit.MILLISECONDS, 1, (queue, task) -> {
                    //拒绝策略：
                    //1.死等
//                        queue.put(task);
                    //2.超时等待
//                        queue.offer(task, 500, TimeUnit.MILLISECONDS);
                    //3.让调用者放弃任务执行
//                        System.out.println("放弃任务");
                    //4.让调用者抛出异常
//                    throw new RuntimeException("任务执行失败" + task);
                    //5.让调用者自己执行任务
//                    task.run();
                });
        for (int i = 0; i < 15; i++) {
            int j = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(j);
            });
        }
    }
}

@FunctionalInterface
interface RejectPolicy<T> {
    void reject(BlockingQueue<T> queue, T task);
}

class ThreadPool {
    private BlockingQueue<Runnable> taskQueue;

    //线程集合
    private HashSet<Worker> workers = new HashSet<>();

    //核心线程数
    private int coreSize;

    //获取任务的超时时间
    private long timeout;

    //时间单位
    private TimeUnit timeUnit;

    //拒绝策略
    private RejectPolicy<Runnable> rejectPolicy;

    //执行任务
    public void execute(Runnable task) {
        //当任务数没有超过coreSize时，直接交给worker对象执行
        //如果任务数超过coreSize时，加入任务队列暂存
        synchronized (workers) {
            if (workers.size() < coreSize) {
                System.out.println("新增worker" + workers);
                Worker worker = new Worker(task);
                workers.add(worker);
                worker.start();
            } else {
                System.out.println("加入任务队列" + task);
                //taskQueue.put(task);
                //拒绝策略：1）死等 2）带超时等待 3）放弃任务执行 4）让调用者抛出异常 5）让调用者自己执行任务
                taskQueue.tryPut(rejectPolicy, task);
            }
        }
    }

    public ThreadPool(int coreSize, long timeout,
                      TimeUnit timeUnit, int queueCapcity, RejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.taskQueue = new BlockingQueue<>(queueCapcity);
        this.rejectPolicy = rejectPolicy;
    }

    class Worker extends Thread{
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //1、当task任务不为空，直接执行任务
            //2、当task执行完毕，再接着从任务队列中获取任务并执行
            while (task != null || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                try {
                    System.out.println("正在执行" + task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            synchronized (workers) {
                System.out.println("worker被移除" + this);
                workers.remove(this);
            }
        }
    }
}

//阻塞队列：放任务的,线程从阻塞队列拿任务执行
class BlockingQueue<T> {
    //1、任务队列
    private Deque<T> queue = new ArrayDeque<>();

    //2、锁
    private ReentrantLock lock = new ReentrantLock();

    //3、生产者条件变量
    private Condition fullWaitSet = lock.newCondition();

    //4、消费者条件变量
    private Condition emptyWaitSet = lock.newCondition();

    //5、容量
    private int capcity;

    public BlockingQueue(int capcity) {
        this.capcity = capcity;
    }

    //带超时的阻塞获取
    public T poll(long timeout, TimeUnit unit) {
        lock.lock();
        try {
            //将timeout统一转换为纳秒
            long nanos = unit.toNanos(timeout);
            while (queue.isEmpty()) {
                try {
                    if (nanos <= 0) {
                        return null;
                    }
                    //返回的是剩余的时间
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //阻塞获取
    public T take() {
        lock.lock();
        try {
            while(queue.isEmpty()) {
                try {
                    emptyWaitSet.await();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //阻塞添加
    public void put(T task) {
        lock.lock();
        try {
            while (queue.size() == capcity) {
                try {
                    System.out.println("等待加入任务队列" +task);
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("加入任务队列" + task);
            queue.addLast(task);
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

    //带超时的阻塞添加
    public boolean offer(T task, long timeout, TimeUnit timeUnit) {
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while (queue.size() == capcity) {
                try {
                    System.out.println("等待加入任务队列" +task);
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("加入任务队列" + task);
            queue.addLast(task);
            emptyWaitSet.signal();
            return true;
        } finally {
            lock.unlock();
        }
    }


    //获取大小
    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

    public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            //判断队列是否已满
            if (queue.size() == capcity) {
                rejectPolicy.reject(this, task);
            } else {//有空闲
                System.out.println("加入任务队列" + task);
            }
        } finally {
            lock.unlock();
        }
    }
}

2、ThreadPoolExecutor

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0DCqsDJX-1607691573955)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208133113021.png)]

1）线程池状态

ThreadPoolExecutor 使用int的高3位来表示线程池状态，低29表示线程数量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O1qECTzD-1607691573960)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208133642572.png)]

从数字上来比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING （首位表示的是符号位，所以RUNNING最小）

这些信息存储在一个原子变量ctl中，目的是将线程状态和线程个数合二为一，这样就可以使用一次cas原子操作进行赋值

//c为旧值 ，ctlof返回结果为新值
ctl.compareAndSet(c, ctlOf(targerState, workerCountOf(c)));

//rs 为高3位代表线程池状态，wc为低29位代表线程个数，ctl是合并他们
private static int ctlOf(int rs, int wc) { return rs | wc; }

2）构造方法

public ThreadPoolExecutor(
		int corePoolSize,    //核心线程数
		int maximumPoolSize,//最大线程数目（核心线程数 + 急救线程数）
		long keepAliveTime, //生存时间-针对救急线程
		TimeUnit unit,     //时间单位-针对救急线程
		BlockingQueue<Runnable> workQueue,     //阻塞队列
		ThreadFactory threadFactory,//线程工厂-可以为线程创建时起一个好名字
		RejectedExecutionHandler handler //拒绝策略
)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1rf1eZS-1607691573966)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208140650738.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMUnXnhy-1607691573967)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208141133077.png)]

3、newFixedThreadPool

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H1lUmcuq-1607691573970)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208142222430.png)]

4、newCachedThreadPool

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YkSNanSY-1607691573972)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208171125583.png)]

5、newSingleThreadExecutor

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FoES39gP-1607691573974)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208172133672.png)]

6、提交任务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clNLpPpO-1607691573976)(C:/Users/lenovo/AppData/Roaming/Typora/typora-user-images/image-20201208173606612.png)]

package com.sharing_model.ThreadPool;

import java.util.concurrent.*;

/**
 * submit:使用了保护性暂停模式
 */
public class SubmitTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //可以使用lambda来进行简化 alt + enter
        Future<String> future = pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("running");
                Thread.sleep(1000);
                return "ok";
            }
        });

        System.out.println(future.get());
    }
}

package com.sharing_model.ThreadPool;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * invokeAll
 */
public class InvokeAllTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        List<Future<String>> futures = pool.invokeAll(Arrays.asList(
                () -> {
                    System.out.println("begin");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    System.out.println("begin");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    System.out.println("begin");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        futures.forEach(f -> {
            try {
                System.out.println(f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }
}

package com.sharing_model.ThreadPool;

import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * invokeAny
 */
public class InvokeAnyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(1);

        String result = pool.invokeAny(Arrays.asList(
                () -> {
                    System.out.println("begin");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    System.out.println("begin");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    System.out.println("begin");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        System.out.println(result);
    }
}

7、关闭线程池

shutdown

/**
* 线程状态变为SHUTDOWN
* -不会接收新任务
* -但已提交任务会执行完
* -此方法不会阻塞调用线程的执行
*/
void shutdown();

shutdownNow

/**
*线程池状态变为STOP
*-不会接受新任务
*-会将队列中的任务返回
*-并且interrup的方式中断正在执行的任务
*/
List<Runnable> shutdownNow();

其它方法

//不在UNNING状态的线程池，此方法就返回true
boolean isShutdown();

//线程池状态是否是 TERMINATED
boolean isTerminated()

//调用shutdown后，由于调用线程并不会等待所有任务运行结，因此如果它想在线程池TERMINATED后做一些事
//情，可以利用此方法等待
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

黄 坤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 线程池
05-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2249853
Java 线程池框架
08-31
Java线程池框架是Java并发处理的核心工具，它允许开发者高效地管理多个并发任务，避免了频繁创建和销毁线程的开销。线程池通过维护一组可重用的线程来提高系统的性能和响应性。本文将深入探讨Java线程池的结构、常见...
如何优雅的使用和理解线程池
weixin_33778778的博客
07-30 340
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的线程池
热门推荐
李江东
04-28 1万+
在我们的开发中经常会使用到多线程。例如在Android中，由于主线程的诸多限制，像网络请求等一些耗时的操作我们必须在子线程中运行。我们往往会通过new Thread来开启一个子线程，待子线程操作完成以后通过Handler切换到主线程中运行。这么以来我们无法管理我们所创建的子线程，并且无限制的创建子线程，它们相互之间竞争，很有可能由于占用过多资源而导致死机或者OOM。
java的线程池
最新发布
qq_51476492的博客
06-16 565
例如，自定义一个线程池，核心线程有3个，临时线程有3个，阻塞队列长度为3。当有8个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建2个临时线程取处理任务7和任务8。当有10个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建3个临时线程取处理任务7、8、9，任务10会触发任务拒绝策略。核心线程数量，线程池中最大线程数量、空闲时间（值）、空闲时间（单位）、阻塞队列、创建线程的方式、要执行的任务过多时的解决方案。
谈谈Java 线程池
09-07
Java线程池是一种高效利用系统资源、管理和控制并发的重要工具。在Java中，线程池的概念借鉴了数据库连接池的思想，旨在通过复用已存在的线程来减少创建和销毁线程的开销，从而提高程序的运行效率。线程池不仅能够...
JAVA线程池原理实例详解
08-26
JAVA线程池原理实例详解 JAVA线程池是java中的一种高效的线程管理机制，它可以控制线程的创建、销毁和复用，从而提高系统的性能和可靠性。下面我们将详细介绍JAVA线程池的原理、创建、使用方法及相关注意事项。 一...
java线程池封装j
08-13
Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...
JAVA线程池例子
04-16
Java线程池是一种高效管理线程资源的技术，它允许开发者创建一组可重用的工作线程，从而避免频繁地创建和销毁线程带来的性能开销。线程池在Java中主要通过`java.util.concurrent`包中的`ExecutorService`接口及其...
Java的线程池
我能在河边钓一整天的鱼
04-02 199
目录 线程池的概念 线程池的使用 线程池的概念 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作。在JDK1.5之后，内置了线程池，我们不需要再手动创建线程池了 线程池的优点 1.降低资源消耗 2.提高响应速度 3.提高线程的可管理性 线程池的使用 1.使用线程池的工厂类Executors里面提供的...
Java-线程池
一蓑烟雨任平生
06-10 314
线程池 1、线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。（是什么） 2、那么，我们为什么需要用到线程池呢？每次用的时候手动创建不行吗？ 在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统
多线程（五） 线程池
qq_35670694的博客
04-20 134
线程池方式 线程池的思想 我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 在Java中可以通过线程池来达到这样的效果...
java 线程池
weixin_44052919的博客
08-27 107
线程池 线程池的优势 （1）、降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗； （2）、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行； （3）方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生内存溢出，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。 （4）提供更强大的功能，延时定时线程池。 1. 线程池的概念： 线程池就是首先创建一些线程，它们的
Java线程池详解与实战应用
Java线程池是Java并发编程中一个核心的概念，它用于管理和复用线程资源，以提高程序性能和资源利用率。学习Java线程池有助于避免频繁创建和销毁线程带来的开销，以及有效控制线程数量，防止系统资源过度消耗导致性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值