ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10, new DiyThreadFactory());
for (int i = 0; i <10 ; i++) {
scheduledExecutorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
自定义ThreadFactory
class DiyThreadFactory implements ThreadFactory{
ThreadGroup group =new ThreadGroup("CONSUMER");
private static String namePrefix="_ORDER_";
private final AtomicInteger threadNumber = new AtomicInteger(1);
@Override
public Thread newThread(Runnable runnable) {
Thread thread = new Thread(group, runnable,
group.getName()+namePrefix+threadNumber.getAndIncrement());
return thread;
}
}
/** * newSingleThreadExecutor * 创建单个线程 创建固定1核心同时最大数量也是1个数线程 大于最大线程池数量1时：将按照顺序执行， 当大于最大Integer时默认直接拒绝 *new LinkedBlockingQueue<Runnable>() * * * * newFixedThreadPool 创建固定核心个数线程 * 大于最大线程池数量时：默认直接拒绝 *new LinkedBlockingQueue<Runnable>() * * * * newScheduledThreadPool * 创建具有调度任务的线程 可以配置核心线程数量和制定工厂 * 大于最大线程池数量时：默认直接拒绝 *new DelayedWorkQueue() * newCachedThreadPool * 创建的线程具有重新使用 可以指定创建线程使用的工厂 *最小核心数为0，最大为INTEGER最大值 * 线程存活时间为60s，60s没被使用将销毁 * 大于最大线程池数量时：默认直接拒绝 * new SynchronousQueue<Runnable> 异步执行 * * * executor.invokeAny(callables)返回线程集合其中一个执行完成的结果 * executor.invokeAll(callables)返回线程集合所有的执行结果 * * executor.submit()有返回结果 * executor.execute()没回结果 */
// 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
// execute 执行但不会返回结果 这个方法有个问题，就是没有办法获知task的执行结果。如果我们想获得task的执行结果，我们可以传入一个Callable的实例
ExecutorService executorService = Executors.newSingleThreadExecutor();
//异步执行
for (int i = 0; i <10 ; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("如果帅有罪，请把我埋葬");
}
});
}
Thread.sleep(1000);
executorService.shutdownNow();
// 这个方法有个问题，就是没有办法获知task的执行结果。如果我们想获得task的执行结果，我们可以传入一个Callable的实例
// 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
// executor.submit 执行会有返回结果， future.get()获取结果会阻塞线程
ExecutorService executorService2 = Executors.newFixedThreadPool(2);
//异步执行
executorService2.execute(new Runnable() {
@Override
public void run() {
System.out.println("cafa babe");
}
});
Future<String> future1 = executorService2.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return "蛟龙入海";
}
});
Future future2 = executorService2.submit(new Runnable() {
@Override
public void run() {
System.out.println("鹰击长空");
}
});
Object o1 = future1.get();
Object o2 = future2.get();
System.out.println(o1);
System.out.println(o2);
executorService2.shutdown();
// invokeAny 返回执行某个线程执行的结果
ExecutorService executorSingleService = Executors.newFixedThreadPool(3);
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
String result = executorSingleService.invokeAny(callables);
System.out.println("result = " + result);
// invokeAll 返回所有线程返回的结果
Set<Callable<String>> callables0 = new HashSet<Callable<String>>();
callables0.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables0.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables0.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
List<Future<String>> futures = executorSingleService.invokeAll(callables0);
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>:" + JSON.toJSONString(futures));
executorSingleService.shutdown();
// 定时任务
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10, Executors.defaultThreadFactory());
// 延迟三秒执行
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
System.out.println("延迟三秒执行");
}
}, 3, TimeUnit.SECONDS);
// 延迟三秒后每三秒执行一次
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("延迟三秒后执行三秒");
}
}, 3, 3, TimeUnit.SECONDS);
// 第一次执行延迟三秒，然后每三秒执行一次
scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
System.out.println("第一次执行延迟三秒，然后每三秒执行一次");
}
}, 3, 3, TimeUnit.SECONDS);
Thread.sleep(1000000);
scheduledExecutorService.shutdown();
//线程池里面的线程数会动态变化，并可在线程线被移除前重用,可以使用之前的线程
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 1; i <= 20; i++) {
int finalI = i;
threadPool.execute(new Runnable() { //接受一个Runnable实例
public void run() {
System.out.println("线程名字： " + Thread.currentThread().getName() + " 任务名为： " + finalI);
}
});
}
threadPool.shutdown();
//核心线程，最大线程数，存活时间，时间单位，队列
ThreadPoolExecutor threadPoolExecutor1=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>());
//核心线程，最大线程数，存活时间，时间单位，队列，工厂方式
ThreadPoolExecutor threadPoolExecutor2=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>(), Executors.defaultThreadFactory());
//核心线程，最大线程数，存活时间，时间单位，队列，大于最大线程数策略
ThreadPoolExecutor threadPoolExecutor3=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS, new LinkedBlockingDeque<>(),new ThreadPoolExecutor.AbortPolicy());
//核心线程，最大线程数，存活时间，时间单位，队列，工厂方式，大于最大线程数策略，
ThreadPoolExecutor threadPoolExecutor4=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
threadPoolExecutor4.execute();
threadPoolExecutor4.submit();
