版权声明:送人玫瑰,手有余香,一分也是爱 https://blog.csdn.net/m0_37156901/article/details/86303104
线程的实现有两种,继承runable,实现Thread 方法, 但是都有缺陷,得不到线程执行的结果,而future 可以。
1. futureTask的使用
package com.mmall.concurrency.AQS;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
@Slf4j
public class FutureDemo {
// 首先声明一个callbale
static class MyCallable implements Callable<String>{
@Override
public String call() throws Exception {
log.info("do something in callable!");
Thread.sleep(5000);
return "Done OK!";
}
}
// 在main方法测试
public static void main(String[] args) throws Exception{
// 在线程池里执行
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> future = executorService.submit( new MyCallable() );
log.info("do something in main!");
Thread.sleep(2000);
// 没有获取到,就在这里阻塞
String result = future.get();
log.info("{}", result);
}
}
2. FutureTask 的使用
使用场景:希望启动一个线程做一件事情,而且期望得到他的结果,
可传入runable,callbale.
package com.mmall.concurrency.AQS;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
@Slf4j
public class FutureTaskDemo {
public static void main(String[] args) throws Exception {
FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
@Override
public String call() throws Exception {
log.info("do something in callable!");
Thread.sleep(5000);
return "Done OK!";
}
});
new Thread(futureTask).start();
log.info("do in main!");
Thread.sleep(2000);
String result = futureTask.get();
log.info("yp:{}", result);
}
}
3. Fork / Join 并行框架
核心: 两个类
思想:把大任务分成小,然后又合并,于MapReduce相似。
采用工作窃取算法。
用的不多,只是熟悉用法流程,
package com.mmall.concurrency.AQS;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
@Slf4j
public class ForkJoinTaskDemo extends RecursiveTask<Integer> {
public static final int threshold = 2;
private int start;
private int end;
public ForkJoinTaskDemo(int start, int end){
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int sum = 0;
//如果任务足够小就计算任务
boolean canCompute = (end - start) <= threshold;
if (canCompute){
for(int i = start; i <= end; i++){
sum += i;
}
}else {
// 如果任务大于阈值,就分裂成两个子任务计算
int middel = (start + end) / 2;
ForkJoinTaskDemo leftTask = new ForkJoinTaskDemo(start, middel);
ForkJoinTaskDemo rightTask = new ForkJoinTaskDemo(middel+1, end);
// 执行子任务
leftTask.fork();
rightTask.fork();
// 等待任务执行结束合并其结果
int leftResult = leftTask.join();
int rightResult = rightTask.join();
// 合并子任务
sum = leftResult + rightResult;
}
return sum;
}
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
// 生成一个计算任务 计算 1+2+3+4
ForkJoinTaskDemo taskDemo = new ForkJoinTaskDemo(1,10000);
// 执行一个任务
Future<Integer> result = forkJoinPool.submit(taskDemo);
try{
log.info("result: {}", result.get());
}catch (Exception e){
log.error("exception", e);
}
}
}
4. 阻塞队列BlockingQueue
入队出队的四套方法
它的实现类--不同场景选择
阻塞队列不仅完整实现了队列的基本功能,还在多线程下提供线程间的等待,唤醒功能