1. public class Test1 {  
2.   
3.      private ThreadPoolExecutor threadpool;  
4.        
5.     /** 
6.      * Param:  
7.      * corePoolSize - 池中所保存的线程数，包括空闲线程。  
8.      * maximumPoolSize - 池中允许的最大线程数(采用LinkedBlockingQueue时没有作用)。  
9.      * keepAliveTime -当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间，线程池维护线程所允许的空闲时间。  
10.      * unit - keepAliveTime参数的时间单位，线程池维护线程所允许的空闲时间的单位:秒 。  
11.      * workQueue - 执行前用于保持任务的队列（缓冲队列）。此队列仅保持由execute 方法提交的 Runnable 任务。  
12.      * RejectedExecutionHandler -线程池对拒绝任务的处理策略(重试添加当前的任务，自动重复调用execute()方法) 
13.      */  
14.       public Test1(){   
15.         threadpool=new ThreadPoolExecutor(2, 10, 20, TimeUnit.SECONDS, new ArrayBlockingQueue(10),   
16.         new ThreadPoolExecutor.DiscardOldestPolicy());   
17.       }   
18.         
19.       //add task into thread pool   
20.       public void submit(final int flag){   
21.         threadpool.execute(new Runnable(){   
22.           public void run(){   
23.             try {   
24.               Thread.sleep(2000);   
25.             } catch (InterruptedException e) {   
26.               e.printStackTrace();   
27.             }   
28.             System.out.println(flag + "   Hello");   
29.           }  
30.         });       
31.       }   
32.           
33.     /** 
34.      * close thread pool 
35.      */  
36.     public void shutdown() {  
37.         threadpool.shutdown();  
38.     }  
39.   
40.     public static void main(String[] args) {  
41.         Test1 t = new Test1();  
42.         for (int i = 0; i < 20; i++) {  
43.             System.out.println("time:" + i);  
44.             t.submit(i);  
45.         }  
46.           
47.         System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");  
48.     }  
49.       
50.     /** 
51.      * 当一个任务通过execute(Runnable)方法欲添加到线程池时： 
52.      * 1.如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。 
53.      * 2.如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。 
54.      * 3.如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。 
55.      * 4.如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 
56.      * handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize 
57.      * ，如果三者都满了，使用handler处理被拒绝的任务。  
58.      *  
59.      * 5.当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。 
60.      */  
61. }  

1. 重写RejectedExecutionHandler

线程池在BlockingQueue用完的情况下，会执行这里。可以利用这个方法把数据存下来。等空闲的时候在运行。

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class UserRejectHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
       try {
				System.out.println("task submission rejected because of queue being full. So may block the thread ");
				e.getQueue().put(r);
				System.out.println("Queue size:"+e.getQueue().size());
				System.out.println("Block released. task submitted");
			} catch (InterruptedException ie) {
				Thread.currentThread().interrupt();
				throw new RejectedExecutionException(ie);
			}
    }
}

2. 创建ThreadFactory 。生产Thread

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
// UserThreadFactory.java
public class UserThreadFactory implements ThreadFactory {
    private final String namePrefix;
    private final AtomicInteger nextId = new AtomicInteger(1);
    UserThreadFactory(String whatFeatureOfGroup) {
        this.namePrefix = "UserThreadFactory's " + whatFeatureOfGroup + "-Worker-";
    }

    public Thread newThread(Runnable runnable) {
        String name = this.namePrefix + nextId.getAndIncrement();
        Thread thread = new Thread(null, runnable, name, 0);
        System.out.println(thread.getName());
        return thread;
    }
}
class Task implements Runnable {
    private final AtomicLong count = new AtomicLong(0L);
    public void run() {
        System.out.println("Starting to run running_" + count.getAndIncrement());
        try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
        System.out.println("End to run running_" + count.getAndIncrement());
    }
}

3. 执行15个任务。

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class UserThreadPool {
    public static void main(String[] args) {
        BlockingDeque<Runnable> blockingDeque = new LinkedBlockingDeque<>(13);
        UserThreadFactory f1 = new UserThreadFactory("UserThreadFactory 1");
        UserRejectHandler handler = new UserRejectHandler();
        ThreadPoolExecutor threadPoolFirst = new ThreadPoolExecutor(1, 2,
                60, TimeUnit.SECONDS, blockingDeque, f1, handler);
        Runnable task = new Task();
        for (int i = 0; i < 15; i++) {
            threadPoolFirst.execute(task);
            System.out.println("threadPoolFirst.execute.."+i);
        }   
    }
}

执行结果

UserThreadFactory's UserThreadFactory 1-Worker-1
threadPoolFirst.execute..0
threadPoolFirst.execute..1
threadPoolFirst.execute..2
Starting to run running_0
threadPoolFirst.execute..3
threadPoolFirst.execute..4
threadPoolFirst.execute..5
threadPoolFirst.execute..6
threadPoolFirst.execute..7
threadPoolFirst.execute..8
threadPoolFirst.execute..9
threadPoolFirst.execute..10
threadPoolFirst.execute..11
threadPoolFirst.execute..12
threadPoolFirst.execute..13
UserThreadFactory's UserThreadFactory 1-Worker-2
threadPoolFirst.execute..14
Starting to run running_1
End to run running_2
End to run running_3
Starting to run running_4
Starting to run running_5
End to run running_6
End to run running_7
Starting to run running_8
Starting to run running_9
End to run running_11
End to run running_10
Starting to run running_12
Starting to run running_13
End to run running_14
End to run running_15
Starting to run running_16
Starting to run running_17
End to run running_18
Starting to run running_20
End to run running_19
Starting to run running_21
End to run running_22
End to run running_23
Starting to run running_24
Starting to run running_25
End to run running_26
Starting to run running_27
End to run running_28
End to run running_29
 

官网文档：https://docs.python.org/zh-cn/3/library/concurrent.futures.html

Python有GIL，故多线程最好只用于io密集型程序，比如需要网络下载很多个文件，下面截取部分代码来展示如何使用：

from concurrent.futures import ThreadPoolExecutor, as_completed # 导入需要的包
threadPool = ThreadPoolExecutor(max_workers=140) # 线程池的池子大小，最多同时执行多少个任务，submit的任务数超过这个数字后后续任务会自行等待进入线程池
all_task = [threadPool.submit(self.download_01, url, path, delay * 1.5)
            for delay, url in enumerate(urls)] # 使用线程池ThreadPoolExecutor的submit方法发起任务，列表生成式里面装了所有任务的返回句柄。self.download_01是我的函数名称，url, path, delay * 1.5 全是我的self.download_01函数的参数。
for task in as_completed(all_task): # as_completed 可以判断列表里的线程是否完成
    data = task.result()
    print("任务{} down load success".format(data)) # 打印结果
threadPool.shutdown(wait=True) #　释放线程池资源