Android java 实现自己线程池

最新推荐文章于 2024-05-21 11:46:49 发布

原创最新推荐文章于 2024-05-21 11:46:49 发布 · 296 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#android #java

android开发，java线程池专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一个自定义线程池的Java实现，包括线程池的基本配置参数、任务执行流程、工作线程管理和线程池关闭机制。该线程池能够根据最小和最大线程数动态调整工作线程数量，并支持任务队列。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * Created by johnny on 2017/2/24.
 */

public class MyThreadPool implements Executor {
    

    private int mMinThreadNum = 0;
    private int mMaxThreadNum = 5;

    private int mThreadKeepTime = 15000;//毫秒

    private LinkedList<Runnable> mTaskList = new LinkedList<>();

    private List<Worker> mWorkList;


    public MyThreadPool() {
        mWorkList = new ArrayList<>(mMaxThreadNum);
    }


    public MyThreadPool(int minThreadNum, int maxThreadNum, int threadKeepTime) {
        mMaxThreadNum = maxThreadNum;
        mMinThreadNum = minThreadNum;

        mThreadKeepTime = threadKeepTime;

        if (minThreadNum < 0 || minThreadNum <= maxThreadNum) {
            throw new IllegalArgumentException("minThreadNum 要大于0 并且小于maxThreadNum");
        }

        mWorkList = new ArrayList<>(mMaxThreadNum);
    }


    public synchronized void execute(Runnable command) {
        if (command == null)
            return;


        Worker worker;

        synchronized (mWorkList) {
            if (mWorkList.size() < mMinThreadNum) {
                createWorker(command);
                return;
            }

            worker = getIdleWorker();
            if (worker != null) {
                synchronized (worker) {
                    worker.mTask = command;
                    worker.notify();
                }
                return;
            }

            if (mWorkList.size() < mMaxThreadNum) {
                createWorker(command);
                return;
            }

        }


        synchronized (mTaskList) {
            mTaskList.add(command);
        }
    }


    public void shutdown() {
        synchronized (mWorkList) {
            while(mWorkList.size() > 0) {
                Worker worker = mWorkList.remove(0);
                if (worker != null) {
                    worker.mIsRunning = false;
                    worker.notify();
                }
            }
        }
    }

    private void createWorker(Runnable runnable) {
        Worker worker = new Worker(runnable);
        Thread thread = new Thread(worker, "MyThreadPool");
        mWorkList.add(worker);
        thread.start();
    }

    private Worker getIdleWorker() {
        for (int i = 0; i < mWorkList.size(); i++) {
            Worker worker = mWorkList.get(i);
            if (worker.mIsRunning && worker.mTask == null) {
                return worker;
            }
        }

        return null;
    }


    class Worker implements Runnable {

        private volatile long mLastRunTime;
        private volatile boolean mIsRunning = true;

        private volatile Runnable mTask;

        Worker(Runnable task) {
            mTask = task;
        }

        public void run() {
            while (mIsRunning) {
                if (mTask == null) {
                    synchronized (mTaskList) {
                      if (!mTaskList.isEmpty()) {
                          mTask = mTaskList.removeFirst();
                      }
                    }
                }

                if (mTask != null) {
                    mLastRunTime = System.currentTimeMillis();

                    mTask.run();
                    mTask = null;

                    mLastRunTime = System.currentTimeMillis();
                } else {
                    if ((System.currentTimeMillis() - mLastRunTime) >= mThreadKeepTime) {
                        synchronized (mWorkList) {
                            if (mTask != null){
                                continue;
                            }

                            if (mWorkList.size() > mMinThreadNum) {
                                
                                mWorkList.remove(this);
                                mIsRunning = false;
                                return;
                            }
                        }
                    }

                    try {
                        synchronized (this) {
                            if (mTask == null) {
                               
                                this.wait(mThreadKeepTime);
                            }
                        }
                    } catch (InterruptedException e) {
                        mIsRunning = false;
                        Thread.currentThread().interrupt();
                        synchronized (mWorkList) {
                            mWorkList.remove(this);
                        }
                    }
                }

            }
        }
    }
}