原子操作
线程并发库，线程池-------Executors类。
public static void main(String[] args) {
//创建既定大小的缓冲池。
// ExecutorService threadPool = Executors.newFixedThreadPool(3);
//创建一个缓冲线程池，按照线程的数量来决定缓冲池的大小。
ExecutorService threadPool = Executors.newCachedThreadPool();
//创建一个单线程的缓冲池，始终保持该线程池中有一个线程，如果当前线程结束，那么该方法会再创建一个线程来接替前一个线程。
// ExecutorService threadPool = Executors.newSingleThreadExecutor();
for(int i=1;i<=12;i++){
final int task = i;
threadPool.execute(new Runnable(){
// static{
// System.out.println("task is committed!");
// }
@Override
public void run() {
for(int j=1;j<=5;j++){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " is looping of " + j + " for task of " + task);
}
}
});
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("all of 10 tasks have committed! ");
// threadPool.shutdown();
//threadPool.shutdownNow();
//
// Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable() {
// @Override
// public void run() {
// System.out.println("bombing!");
// }
file:///C:/Users/dell/AppData/Local/Temp/ksohtml/wps_clip_image-3526.png// }, 6, 2, TimeUnit.SECONDS);
file:///C:/Users/dell/AppData/Local/Temp/ksohtml/wps_clip_image-6042.png
Executors.newScheduledThreadPool(2).schedule(new Runnable(){
@Override
public void run() {
System.out.println("baozha!");
}
}, 3, TimeUnit.SECONDS);
}
----------用线程池启动定时器
file:///C:/Users/dell/AppData/Local/Temp/ksohtml/wps_clip_image-11656.png
调用ScheduledExecutorService的schedule方法，返回的ScheduleFuture对象可以取消任务。
支持间隔重复任务的定时方式，不直接支持绝对定时方式，需要转换成相对时间方式。
-----(来自JDK)以下是一个带方法的类，它设置了 ScheduledExecutorService ，在 1 小时内每 10 秒钟蜂鸣一次：
----------Callable&Future---------
Callable 和Runnable接口的区别：
Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。
FutureTask 类是 Future 的一个实现，Future 可实现 Runnable，所以可通过 Executor 来执行。FutureTask 属于代理类 ，负责启动Callable对象，并且可以通过它来获得Callable的返回信息。
FutureTask<String> future = new FutureTask<String>( new Callable<String>() {
public String call() {
return searcher.search(target);
}
});
executor.execute(future);
----------------
public class CallableAndFuture {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future<String> future =
threadPool.submit(
new Callable<String>() {
public String call() throws Exception {
Thread.sleep(2000);
return "hello";
};
}
);
System.out.println("等待结果");
try {
System.out.println("拿到结果：" + future.get());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//提交一组任务用CompletionService
ExecutorService threadPool2 = Executors.newFixedThreadPool(14);
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);
//处理返回的feinull的每个结果。
//void solve(Executor e, Collection<Callable<Result>> solvers)throws InterruptedException, ExecutionException {
// CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
// for (Callable<Result> s : solvers)
// ecs.submit(s);
// int n = solvers.size();
// for (int i = 0; i < n; ++i) {
// Result r = ecs.take().get();
// if (r != null)
// use(r);
// }
// }
//使用第一个返回的非null的且不抛异常的结果，并在接受到结果之后就取消其他任务。
// void solve(Executor e, Collection<Callable<Result>> solvers) throws InterruptedException {
// CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
// int n = solvers.size();
// List<Future<Result>> futures = new ArrayList<Future<Result>>(n);
// Result result = null;
// try {
// for (Callable<Result> s : solvers)
// futures.add(ecs.submit(s));
// for (int i = 0; i < n; ++i) {
// try {
// Result r = ecs.take().get();
// if (r != null) {
// result = r;
// break;
// }
// } catch(ExecutionException ignore) {}
// }
// }
// finally {
// for (Future<Result> f : futures)
// f.cancel(true);
// }
//
// if (result != null)
// use(result);
// }
for(int i=1;i<=10;i++){
final int seq = i;
completionService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
Thread.sleep(new Random().nextInt(5000));
return seq;
}
});
}
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) | 黑马程序员IT技术论坛 X3.2 |