Java线程池的实现

方法1：Java自带的线程池

采用Executors的factory method创建了固定大小的线程池，采用execute()方法添加Runnable Task。

1 ExecutorService threadPool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 4; i++)
     threadPool.execute(new InnerWork(i + ""));
threadPool.shutdown();

内部实现是采用LinkedBlockingQueue。

/**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue.  At any point, at most
     * <tt>nThreads</tt> threads will be active processing tasks.
     * If additional tasks are submitted when all threads are active,
     * they will wait in the queue until a thread is available.
     * If any thread terminates due to a failure during execution
     * prior to shutdown, a new one will take its place if needed to
     * execute subsequent tasks.  The threads in the pool will exist
     * until it is explicitly {@link ExecutorService#shutdown shutdown}.
     *
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if <tt>nThreads &lt;= 0</tt>
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

方法2：采用BlockingQueue编程实现一个大小可变的线程池。

思路：

1.线程池的功能有①执行线程任务execute()；②停止线程任务shutdown()。

2.用BlockingQueue<Runnable> 存放Runnable Task，add(Runnable task)添加Task，take()取出Task执行。List<Thread> 保存线程，为了实现shutdown().

3.内部类的实现控制线程池。内部类采用while死循环来保证运行“实际运行的Task”运行，死循环可以保持线程不消亡。

 实现的线程池：MyThreadPool.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class MyThreadPool {
    static BlockingQueue<Runnable> queue;
    List<Thread> threads;

    MyThreadPool(int threadNum) {
        MyThreadPool.queue = new LinkedBlockingQueue<Runnable>();
        this.threads = new ArrayList<Thread>(threadNum);
        for (int i = 0; i < threadNum; i++) {
            Thread t = new InnerThread();
            t.start();
            threads.add(t);
        }
    }

    //设计的思路：利用while死循环来控制线程的启动。注意：while(true)的位置在try里面，这样捕获到异常才可以跳出while循环。
    static class InnerThread extends Thread {
        public void run() {
            try {
                while (true) {
                    queue.take().run();
                }
            } catch (InterruptedException e) {
                System.out.println("One thread is dying!");
            }
        }
    }

    void execute(Runnable task) {
        queue.add(task);
    }

    void shutdown() {
        for (Thread t : threads) {
            t.interrupt();
        }
    }
}

使用线程池:Main.java

//Main.java
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    static List<Integer> block = new LinkedList<Integer>();
    static {
        block = Collections.synchronizedList(block);
        for (int i = 0; i < 1500; i++) {
            block.add(i);
        }
    }

    public static void main(String[] args) {
        // 方法1：Java线程池的用法
        // ExecutorService threadPool = Executors.newFixedThreadPool(2);
        // 方法2：自己实现的线程池
        MyThreadPool threadPool = new MyThreadPool(2);
        for (int i = 0; i < 10; i++)
            threadPool.execute(new InnerWork(i + ""));
        threadPool.shutdown();
    }

    static class InnerWork implements Runnable {
        String name;

        public InnerWork(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++)
                System.out.println(name + " :  " + block.remove(0));
        }

    }
}