线程池的研究
前期准备程序
Executor executor = ExecutorUtils.getExecutor(2);
创建新的线程，直接在最外层Executor
new Thread(new Runnable() {
@Override
public void run() {
while (true){
executor.execute(()->{
logger.info(Thread.currentThread().getName());
});
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
效果是每秒钟线程池内的线程交替打印。
创建新的线程，在里面sleep
new Thread(new Runnable() {
@Override
public void run() {
while (true){
executor.execute(()->{
logger.info(Thread.currentThread().getName());
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}).start();
代码直接出现异常。
直接在外部使用执行方法
executor.execute(()->{
logger.info(Thread.currentThread().getName());
});
只打印了一次。
直接在外部循环打印
executor.execute(()->{
while (true){
logger.info(Thread.currentThread().getName());
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
只用到了一个线程。从这个实验我们可以得出一个结论，线程池的一堆线程是并发的时候使用的，如果没有形成并发，就不会使用新的线程。 所以我进行了接下来的尝试。
同时直接在外面调用两个外部循环打印
executor.execute(()->{
while (true){
logger.info(Thread.currentThread().getName());
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
executor.execute(()->{
while (true){
logger.info(Thread.currentThread().getName());
try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
可以发现这就是并发的了。那么如果我想只在一个execute调用里面实现这样的功能该怎么做呢？
总结
Executor.execute仅仅只是执行代码，如果想要并发执行，只能进行多次调用。即，下面为完整的例子：
PriorityBlockingQueue<Integer> task = new PriorityBlockingQueue<>();
Executor executor = ExecutorUtils.getExecutor(2);
new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
Thread.sleep(2*100);
} catch (InterruptedException e) {
e.printStackTrace();
}
task.add(new Double(Math.random()*10000).intValue());
}
}
}).start();
for (int i=0;i<2;i++){
executor.execute(() -> {
while (true) {
Integer value = null;
try {
value = task.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (Objects.nonNull(value)){
logger.info(value);
try {
Thread.sleep(MathUtils.getPositiveRandomInt(3)*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
}
我用一个线程每隔200毫秒向队列里面丢一个数字，然后用线程池去取。然后executor.execute通过循环调用两次。就可以实现抢占式线程池调用了。
得想想上面的代码如何工具化。
批量执行任务集
ExecutorService service = ExecutorUtils.getExecutorService(2);
List<Callable<Integer>> listTask = new ArrayList<>();
for (int i = 0; i < 100; i++) {
listTask.add(() -> {
int l = MathUtils.getPositiveRandomInt(100);
int r = MathUtils.getPositiveRandomInt(100);
Integer value = MathUtils.getRandomInt(Math.min(l, r), Math.max(l, r));
logger.info(value);
Thread.sleep(value);
return value;
});
}
try {
List<Future<Integer>> futures = service.invokeAll(listTask);
logger.info("------------------------------------");
for (int i=0;i<100;i++){
try {
logger.info(futures.get(i).get());
} catch (Exception e) {
e.printStackTrace();
}
}
service.shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
这种方式适合于批量执行任务，但是事先需要确定出总的任务量，等到执行完了再出结果。
通过
List<Future<Integer>> futures = service.invokeAll(listTask);
得到返回值，可以做一些合并操作。该方法适用于放在逐层局部需要进行并发执行的过程，例如爬虫，爬取一个网站的时候可以考虑逐层爬取，就可以使用该方法来做。
总结
当我们需要使用线程池的时候，如果不确定需要处理的对象有多少，就采用队列的方式，利用阻塞队列和抢占式的方法来实现线程池。如果对于每一次并发任务，知道
