栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

自定义线程池

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

自定义线程池

自定义线程池

文章目录
    • 自定义线程池
      • 自定义线程池

线程池的概述

​ 线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中。如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队,但他们要等到其他线程完成后才启动。

  • 线程池的七大核心参数:
  1. corePoolSize: 核心线程数目 - 池中会保留的最多线程数。

  2. maximumPoolSize: 最大线程数目 - 核心线程+救急线程的最大数目。

  3. keepAliveTime: 生存时间 - 救急线程的生存时间,生存时间内没有新任务,此线程资源会释放。

  4. unit: 时间单位 - 救急线程的生存时间单位,如秒、毫秒等。

  5. workQueue: - 当没有空闲核心线程时,新来任务会加入到此队列排队,队列满会创建救急线程执行任务。

  6. threadFactory: 线程工厂 - 可以定制线程对象的创建,例如设置线程名字、是否是守护线程等。

  7. handler: 拒绝策略 - 当所有线程都在繁忙,workQueue 也放满时,会触发拒绝策略。

(1)抛异常 java.util.concurrent.ThreadPoolExecutor.AbortPolicy。

(2)由调用者执行任务 java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy。

(3)丢弃任务 java.util.concurrent.ThreadPoolExecutor.DiscardPolicy。

(4)丢弃最早排队任务 java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy。

  • 线程池的基本工作方式:

​ 提交任务到线程池,线程池拿到任务后判断当前的线程池的线程数是否达到了最大线程数,如果没有达到当核心线程都没有空闲时就会创建救急线程来执行该任务,如果达到了最大线程线程数当前任务在等待队列没满的情况下就会加到任务的阻塞队列等待,队列满了就会执行对应的拒绝策略。

  • jdk提供的现场池:
    • 固定大小线程池
    • 定时任务线程池
    • 单线程线程池
    • 带缓冲的线程池
自定义线程池
  • 等待队列
package com.qiumin;

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


public class BlockingQueue {

    
    private final Deque queue = new ArrayDeque<>();

    
    private final ReentrantLock lock = new ReentrantLock();

    
    private final Condition fullWaitSet = lock.newCondition();

    
    private final Condition emptyWaitSet = lock.newCondition();

    
    private int capacity;

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

    
    public T poll(Long timeout, TimeUnit unit){
        lock.lock();
        try {
            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 element){
        lock.lock();
        try {
            while (queue.size()==capacity){
                try {
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("任务加入阻塞队列中===="+element);
            queue.addLast(element);
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
    }

    
    public Boolean offer(T element,Long timeout, TimeUnit unit){
        lock.lock();
        try {
            Long nanos = unit.toNanos(timeout);
            while (queue.size()==capacity){
                try {
                    if (nanos<=0){
                        return false;
                    }
                    //返回剩余时间
                   nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("任务加入阻塞队列中===="+element);
            queue.addLast(element);
            emptyWaitSet.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }

    
    public void tryPut(ThreadPool.RejectPolicy rejectPolicy,T element){
        lock.lock();
        try {
            if(queue.size()==capacity){
                rejectPolicy.reject(this,element);
            }else {
                System.out.println("任务加入阻塞队列中===="+element);
                queue.addLast(element);
                emptyWaitSet.signal();
            }
        }finally {
            lock.unlock();
        }
    }



    
    public int getSize(){
        lock.lock();
        try{
            return queue.size();
        }finally {
            lock.unlock();
        }
    }

}

  • 线程池
package com.qiumin;

import java.util.HashSet;
import java.util.concurrent.TimeUnit;


public class ThreadPool {

    
    private BlockingQueue taskQueue;

    
    private HashSet workers = new HashSet<>();

    
    private int coreSize;

    
    private RejectPolicy rejectPolicy;

    
    private long timeout;

    
    private TimeUnit timeUnit;

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

    interface RejectPolicy{
        void reject(BlockingQueue taskQueue,T task);
    }

    
    public void executor(Runnable task){
       synchronized (workers) {
           if(workers.size()
               Worker worker = new Worker(task);
               System.out.println("新增worker线程===="+worker+"----任务==="+task);
               workers.add(worker);
               worker.start();
           }else {
//               taskQueue.put(task);
               taskQueue.tryPut(rejectPolicy,task);
           }
       }
    }

    class Worker extends Thread{
        private Runnable task;

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

        @Override
        public void run() {

            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);
            }
        }

    }
}

  • 测试
package com.qiumin;

import java.util.concurrent.TimeUnit;


public class TestThreadPool {
    public static void main(String[] args) {
        ThreadPool pool = new ThreadPool(1, 3000, TimeUnit.MILLISECONDS, 1,(taskQueue,task) -> {
            //死等
            //taskQueue.put(task);
            //超时等待
            taskQueue.offer(task,500L,TimeUnit.MILLISECONDS);
            //放弃任务
            //System.out.println("放弃任务");
            //抛出异常
            //throw new RuntimeException("异常");
            //主线程自己执行任务
            //task.run();
        });
        for (int i = 0; i < 3; i++) {
            int j=i;
            pool.executor(()->{
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(j);
            });

        }
    }
}
  • 测试结果

qiumin

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/953231.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号