new CachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收则新建线程
这种类型的线程池的特点是:
- 工作线程的创建几乎没有限制(其实也是有限制的,数目为Integer.MAX_VALUE),这样可以灵活的往线程池中添加线程
- 如果长时间没有往线程池中提交任务,即如果工作线程空闲了指定的时候(默认1分钟),则该工作线程将自动终止。终止之后,如果你又提交了新的任务,则线程重新创建一个工作线程
- 在使用CachedThreadPool时,一定要注意控制任务的数量,否则,由于大量线程同时运行,很可能会造成系统瘫痪
package aaa;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolDemo1 {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for(int i = 0 ; i<15;i++){
final int index = i;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(index);
}
});
}
}
}
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
创建一个指定工作线程数量的线程池,没当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到等待队列中
FixedThreadPool是一个典型且优秀的线程池,它具有线程池提高程序效率和节省创建线程时消耗的开销的优点。但是,在线程池空闲时,即线程池中没有可运行任务时,它不会释放工作线程,还会占用一定的系统资源。
案例
package aaa;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixThreadPoolDemo {
public static void main(String[] args) {
ExecutorService FixedThreadPool = Executors.newFixedThreadPool(5);
for(int i = 0 ; i< 15;i++){
final int index = i;
FixedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
上面案例中的线程池大小为3,每个任务输出index后睡眠2秒,所以每2秒打印3个数字。
newSingleThreadExecutor
创建一个单线程化的Executor,即只创建唯一的工作线程来执行任务,它只会用唯一的工作线程来执行任务,保证所有任务按照制定顺序(FIFO,LIFO优先级)执行,如果这个线程异常结束,会有另一个取代它,保证顺序执行,单工作线程最大的特点是可保证顺序的执行各个任务,并且在任意给定的时间不会有多个线程是活动的。
案例
package aaa;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutor {
public static void main(String[] args) {
ExecutorService SingleThreadExecutor = Executors.newSingleThreadExecutor();
for(int i = 0 ; i<15;i++){
final int index = i;
SingleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(index);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}
}
newScheduleThreadPool
创建一个定长的线程池,而且支持定时的以及周期性的任务执行
案例一
package aaa;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduleThreadPoolDemo {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 延时1秒执行
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("延时1秒执行");
}
}, 3, TimeUnit.SECONDS);
}
}
案例二
package aaa;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduleThreadPoolDemo2 {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 延时1秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("延时1秒后每3秒执行一次");
}
}, 1,3, TimeUnit.SECONDS);
}
}