为了更好的控制多线程,进jdk提供了一套线程框架Executor ,它在Java.util.concurrent包中,是jdk并发报的核心,其中有一个重要的类:
Executors,它扮演这个线程工厂的角色,我们通过Executors可以创建特定的功能线程池。
1. newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
2. newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
3. newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
4. newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)
- ExecutorService executorService = Executors.newSingleThreadExecutor();
- executorService.execute(new Runnable() {
- public void run() {
- System.out.println("Asynchronous task");
- }
- });
- executorService.shutdown();
package com.dt.thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
class Temp extends Thread {
@Override
public void run() {
System.out.println("run");
}
}
public class ScheduleJob {
public static void main(String[] args) {
Temp temp = new Temp();
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
//1表示初始化1秒钟后执行,3表示每隔3秒执行1次
scheduledExecutorService.scheduleWithFixedDelay(temp, 1, 3, TimeUnit.SECONDS);
}
}
------------------------------------------------------------------------------------------------------------------------------
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) //后两个参数为可选参数
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, //使用一个基于FIFO排序的阻塞队列,在所有corePoolSize线程都忙时新任务将在队列中等待 new LinkedBlockingQueue<Runnable>()); }
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService //corePoolSize和maximumPoolSize都等于,表示固定线程池大小为1 (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }
------------------------------------------------------------------------------------------------------------------------------
public
class
CallableAndFuture {
public
static
void
main(String[] args)
throws
ExecutionException, InterruptedException {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(
new
Callable<String>() {
//接受一上callable实例
public
String call()
throws
Exception {
return
"MOBIN"
;
}
});
System.out.println(
"任务的执行结果:"
+future.get());
}
}
--------------------
public
class
CompletionServiceTest {
public
static
void
main(String[] args)
throws
InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(
10
);
//创建含10.条线程的线程池
CompletionService completionService =
new
ExecutorCompletionService(executor);
for
(
int
i =
1
; i <=
10
; i ++) {
final
int
result = i;
completionService.submit(
new
Callable() {
public
Object call()
throws
Exception {
Thread.sleep(
new
Random().nextInt(
5000
));
//让当前线程随机休眠一段时间
return
result;
}
});
}
System.out.println(completionService.take().get());
//获取执行结果
}
}
-------------------------------------------------------------------------------------------------
public
class
ThreadPoolTest {
public
static
void
main(String[] args)
throws
InterruptedException {
ExecutorService threadPool = Executors.newCachedThreadPool();
//线程池里面的线程数会动态变化,并可在线程线被移除前重用
for
(
int
i =
1
; i <=
3
; i ++) {
final
int
task = i;
//10个任务
//TimeUnit.SECONDS.sleep(1);
threadPool.execute(
new
Runnable() {
//接受一个Runnable实例
public
void
run() {
System.out.println(
"线程名字: "
+ Thread.currentThread().getName() +
" 任务名为: "
+task);
}
});
}
}
}