Java使⽤newThread和线程池的区别
执⾏⼀个异步任务你还只是如下new Thread吗
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();
说说弊端：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统⼀管理，可能⽆限制新建线程，相互之间竞争，及可能占⽤过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执⾏、定期执⾏、线程中断。
相⽐new Thread，Java提供的四种线程池的好处在于：
a. 重⽤存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最⼤并发线程数，提⾼系统资源的使⽤率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执⾏、定期执⾏、单线程、并发数控制等功能。
2.Executors提供四种线程池
newCachedThreadPool创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程。线程池的规模不存在限制。
newFixedThreadPool 创建⼀个固定长度线程池，可控制线程最⼤并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建⼀个固定长度线程池，⽀持定时及周期性任务执⾏。
newSingleThreadExecutor 创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执⾏。
下⾯代码说明：
(1). newCachedThreadPool
创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程。⽰例代码如下：ExecutorService cachedThreadPool = wCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
@Override
public void run() {
System.out.println(index);
}
});
}
线程池为⽆限⼤，当执⾏第⼆个任务时第⼀个任务已经完成，会复⽤执⾏第⼀个任务的线程，⽽不⽤每次新建线程。
(2). newFixedThreadPool
创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待。⽰例代码如下：
ExecutorService fixedThreadPool = wFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
因为线程池⼤⼩为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的⼤⼩最好根据系统资源进⾏设置。
(3) newScheduledThreadPool
创建⼀个定长线程池，⽀持定时及周期性任务执⾏。延迟执⾏⽰例代码如下：
ScheduledExecutorService scheduledThreadPool = wScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表⽰延迟3秒执⾏。
定期执⾏⽰例代码如下：
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
表⽰延迟1秒后每3秒执⾏⼀次。
ScheduledExecutorService⽐Timer更安全，功能更强⼤。
(4)、newSingleThreadExecutor
创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执⾏。⽰例代码如下：ExecutorService singleThreadExecutor = wSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
结果依次输出，相当于顺序执⾏各个任务。
2.ExecutorService中submit和execute的区别
以下这是submit 的源码：
public abstract class AbstractExecutorService implements ExecutorService {
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
//....
}
可以看出submit最终返回的是FutureTask对象，⽽execute:
public interface Executor {
void execute(Runnable command);
}
具体的实现在ThreadPoolExecutor类中
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
所以，submit内部调⽤execute，且submit有返回值，⽅便exception处理。submit Demo:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import urrent.Callable;
import urrent.ExecutionException;
import urrent.ExecutorService;
import urrent.Executors;
import urrent.Future;
public class Main {
public static void main(String[] args) {
ExecutorService executorService = wCachedThreadPool();
List<Future<String>> resultList = new ArrayList<Future<String>>();
// 创建10个任务并执⾏
for (int i = 0; i < 10; i++) {
// 使⽤ExecutorService执⾏Callable类型的任务，并将结果保存在future变量中
Future<String> future = executorService.submit(new TaskWithResult(i));
// 将任务执⾏结果存储到List中
resultList.add(future);
}
executorService.shutdown();
// 遍历任务的结果
for (Future<String> fs : resultList) {
try {
System.out.()); // 打印各个线程（任务）执⾏的结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
executorService.shutdownNow();
e.printStackTrace();
return;
}
}
}
}
class TaskWithResult implements Callable<String> {
private int id;java线程池创建的四种
public TaskWithResult(int id) {
this.id = id;
}
/**
* 任务的具体过程，⼀旦任务传给ExecutorService的submit⽅法，则该⽅法⾃动在⼀个线程上执⾏。
*
* @return
* @throws Exception
*/
public String call() throws Exception {
System.out.println("call()⽅法被⾃动调⽤,⼲活 " + Thread.currentThread().getName());
if (new Random().nextBoolean())
throw new TaskException("Meet error in task." + Thread.currentThread().getName());
// ⼀个模拟耗时的操作
for (int i =9; i > 0; i--)
;
return "call()⽅法被⾃动调⽤，任务的结果是：" + id + " " + Thread.currentThread().getName();
}
}
class TaskException extends Exception {
public TaskException(String message) {
super(message);
}
}
Runnable和Callable的区别是，
(1)Callable规定的⽅法是call(),Runnable规定的⽅法是run().
(2)Callable的任务执⾏后可返回值，⽽Runnable的任务是不能返回值得
(3)call⽅法可以抛出异常，run⽅法不可以
(4)运⾏Callable任务可以拿到⼀个Future对象，表⽰异步计算的结果。它提供了检查计算是否完成的⽅法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执⾏情况，可取消任务的执⾏，还可获取执⾏结果。
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论