1、new Thread的弊端
执行一个异步任务你还只是如下new Thread吗?
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();
那你就out太多了,new Thread的弊端如下:
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能,如定时执行、定期执行、线程中断。
相比new Thread,Java提供的四种线程池的好处在于:
a. 重用存在的线程,减少对象创建、消亡的开销,性能佳。
b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
2、Java 线程池
Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
3、以下例子是我在公司编写代码时所执行的基本方案
package com.shuang.executorservice;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* ExecutorService线程池的使用
* 这里只是执行了一个线程的任务为例
* @author shuang
*
*/
public class ExecutorServiceTest {
//线程运行后需要得到的结果之一
private String strString = null;
//实例化
private static ExecutorServiceTest INSTANCE = new ExecutorServiceTest();
//获取单实例
public static ExecutorServiceTest getInstance(){
return INSTANCE;
}
//构造方法私有化
private ExecutorServiceTest(){
ExecutorService executor = null;
try {
executor = Executors.newFixedThreadPool(3, new SelfThreadFactory("shuang-thread"));
Future<String> future = executor.submit(new TestTask());
strString = future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}finally {
if(executor != null){
executor.shutdown();
}
}
}
public String getStrString(){
return strString;
}
}
package com.shuang.executorservice;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 线程工厂
* @author shuang
*
*/
public class SelfThreadFactory implements ThreadFactory {
//线程组
private final ThreadGroup group;
//可以使用院子方式更新的int值。有关院子变量属性的描述
private final AtomicInteger threadNumber = new AtomicInteger(1);
//线程名前缀
private final String namePrefix;
/**
* 构造器
* @param name 线程名
*/
public SelfThreadFactory(String name) {
//安全管理器,相关介绍可以看APi文档
SecurityManager securityManager = System.getSecurityManager();
group = securityManager == null?Thread.currentThread().getThreadGroup():securityManager.getThreadGroup();
namePrefix = new StringBuilder().append(name).append("-").toString();
}
@Override
public Thread newThread(Runnable target) {
//分配新的Thread对象,以便将target作为其中运行对象。
//将指定的name作为其名称,作为group所引用的线程组的一员,并具有指定的堆栈大小
Thread thread =new Thread(
group,
target,
new StringBuilder().append(namePrefix).append(threadNumber.getAndIncrement()).toString(),
0);
if(thread.isDaemon()){//守护线程
thread.setDaemon(false);
}
if(thread.getPriority() != 5){//优先级
thread.setPriority(5);
}
return thread;
}
}
package com.shuang.executorservice;
import java.util.concurrent.Callable;
/**
* 测试任务类-其中一个
* @author shuang
*
*/
public class TestTask implements Callable<String> {
@Override
public String call() throws Exception {
return "this is OK!";
}
}
package com.shuang.executorservice;
//测试类
public class Test {
public static void main(String[] args) {
System.out.println(ExecutorServiceTest.getInstance().getStrString());
}
}