主类：MultiThread，执行并发类
 
package java8test;
 
import java.util.ArrayList;
 
import java.util.List;
 
import java.util.concurrent.BlockingQueue;
 
import java.util.concurrent.Callable;
 
import java.util.concurrent.CountDownLatch;
 
import java.util.concurrent.ExecutionException;
 
import java.util.concurrent.ExecutorService;
 
import java.util.concurrent.Executors;
 
import java.util.concurrent.Future;
 
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 
* @param 为被处理的数据类型
 
* @param 返回数据类型
 
* 知识点1：X,T为泛型，为什么要用泛型，泛型和Object的区别请看：https://www.cnblogs.com/xiaoxiong2015/p/12705815.html
 
*/
 
public abstract class MultiThread {
 
public static int i = 0;
 
// 知识点2：线程池:https://www.cnblogs.com/xiaoxiong2015/p/12706153.html
 
private final ExecutorService exec; // 线程池
 
// 知识点3：@author Doung Lea 队列：https://www.cnblogs.com/xiaoxiong2015/p/12825636.html
 
private final BlockingQueue> queue = new LinkedBlockingQueue<>();
 
// 知识点4：计数器，还是并发包大神 @author Doug Lea 编写。是一个原子安全的计数器，可以利用它实现发令枪
 
private final CountDownLatch startLock = new CountDownLatch(1); // 启动门，当所有线程就绪时调用countDown
 
private final CountDownLatch endLock; // 结束门
 
private final List listData;// 被处理的数据
 
/**
 
* @param list list.size()为多少个线程处理，list里面的H为被处理的数据
 
*/
 
public MultiThread(List list) {
 
if (list != null && list.size() > 0) {
 
this.listData = list;
 
exec = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); // 创建线程池，线程池共有nThread个线程
 
endLock = new CountDownLatch(list.size()); // 设置结束门计数器，当一个线程结束时调用countDown
 
} else {
 
listData = null;
 
exec = null;
 
endLock = null;
 
}
 
}
 
/**
 
*
 
* @return 获取每个线程处理结速的数组
 
* @throws InterruptedException
 
* @throws ExecutionException
 
*/
 
public List getResult() throws InterruptedException, ExecutionException {
 
List resultList = new ArrayList<>();
 
if (listData != null && listData.size() > 0) {
 
int nThread = listData.size(); // 线程数量
 
for (int i = 0; i < nThread; i++) {
 
X data = listData.get(i);
 
Future future = exec.submit(new Task(i, data) {
 
@Override
 
public T execute(int currentThread, X data) {
 
return outExecute(currentThread, data);
 
}
 
}); // 将任务提交到线程池
 
queue.add(future); // 将Future实例添加至队列
 
}
 
startLock.countDown(); // 所有任务添加完毕，启动门计数器减1，这时计数器为0，所有添加的任务开始执行
 
endLock.await(); // 主线程阻塞，直到所有线程执行完成
 
for (Future future : queue) {
 
resultList.add(future.get());
 
}
 
exec.shutdown(); // 关闭线程池
 
}
 
return resultList;
 
}
 
/**
 
* 每一个线程执行的功能，需要调用者来实现
 
* @param currentThread 线程号
 
* @param data 每个线程被处理的数据
 
* @return T返回对象
 
*/
 
public abstract T outExecute(int currentThread, X data);
 
/**
 
* 线程类
 
*/
 
private abstract class Task implements Callable {
 
private int currentThread;// 当前线程号
 
private X data;
 
public Task(int currentThread, X data) {
 
this.currentThread = currentThread;
 
this.data = data;
 
}
 
@Override
 
public T call() throws Exception {
 
// startLock.await(); // 线程启动后调用await，当前线程阻塞，只有启动门计数器为0时当前线程才会往下执行
 
T t = null;
 
try {
 
t = execute(currentThread, data);
 
} finally {
 
endLock.countDown(); // 线程执行完毕，结束门计数器减1
 
}
 
return t;
 
}
 
/**
 
* 每一个线程执行的功能
 
* @param currentThread 线程号
 
* @param data 每个线程被处理的数据
 
* @return T返回对象
 
*/
 
public abstract T execute(int currentThread, X data);
 
}
 
}
 
结果类：ResultVO，保存返回结果，根据实际情况替换成自己的
 
package java8test;
 
public class ResultVo {
 
int i;
 
public ResultVo(int i) {
 
this.i = i;
 
}
 
public ResultVo() {
 
// TODO Auto-generated constructor stub
 
}
 
}
 
参数类：ParamVO,传入参数类，根据实际情况替换成自己的
 
package java8test;
 
public class ParamVo {
 
private int i;
 
ParamVo(int i) {
 
this.i = i;
 
}
 
public int getI() {
 
return i;
 
}
 
@Override
 
public String toString() {
 
return String.valueOf(i) + " " + hashCode();
 
}
 
}
 
测试类：new两个MultiThread，可以看到MultiThread这个类不存在线程安全问题。
 
package java8test;
 
import java.util.ArrayList;
 
import java.util.List;
 
public class Test {
 
public static void main(String[] args) {
 
try {
 
List splitList = new ArrayList();
 
for (int i = 0; i < 100; i++) {
 
splitList.add(new ParamVo(i));
 
}
 
List splitList1 = new ArrayList();
 
for (int i = 200; i < 300; i++) {
 
splitList1.add(new ParamVo(i));
 
}
 
MultiThread multiThread = new MultiThread(splitList) {
 
@Override
 
public ResultVo outExecute(int currentThread, ParamVo data) {
 
System.out.println("当前线程名称：" + Thread.currentThread().getName() + "当前线程号=" + currentThread
 
+ " data=" + data);
 
i--;
 
return new ResultVo(data.getI());
 
}
 
};
 
MultiThread multiThread1 = new MultiThread(splitList1) {
 
@Override
 
public ResultVo outExecute(int currentThread, ParamVo data) {
 
System.out.println("当前线程名称：" + Thread.currentThread().getName() + "当前线程号=" + currentThread
 
+ " data=" + data);
 
i--;
 
return new ResultVo(data.getI());
 
}
 
};
 
List list = multiThread.getResult();
 
List list1 = multiThread1.getResult();
 
// 获取每一批次处理结果
 
System.out.println("获取处理结果........................");
 
for (ResultVo vo : list) {
 
System.out.println(vo.i);
 
}
 
System.out.println("获取1处理结果........................");
 
for (ResultVo vo : list1) {
 
System.out.println(vo.i);
 
}
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
}
 
}
 
这个类也用在了生产当中，用来并发插入数据。但是事务不能被管控，需要自己保证最终事务一致。需要注意。
 

 

 
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

开启线程池并需要获取结果归集的情况下，如何实现，以及优劣,下面是任务执行完，结果归集时，几种方式：
 
一.ExecutorService+Futrue
 
原理:
 
Future接口封装了取消，获取线程结果，以及状态判断是否取消，是否完成这几个方法
 
 
demo:
 
使用线程池提交Callable接口任务，返回Future接口，添加进list,最后遍历FutureList且内部使用while轮询,并发获取结果
 
(1)、创建线程池
 
ExecutorService exs = Executors.newFixedThreadPool(10);
 
(2)、创建Future结果集list
 
List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
 
(3)、提交10个任务，每个任务结果返回到FutureList里面
 
  for (int i = 0; i < 10; i++) {
   	futureList.add(exs.submit(new CallableTask(i + 1)));
  }
 
(4)、结果归集，用迭代器遍历futureList,高速轮询，任务完成就移除
 
 while(futureList.size()>0){

Iterator<Future<Integer>> iterable = futureList.iterator();

//遍历一遍
while(iterable.hasNext()){
	Future<Integer> future = iterable.next();
		/如果任务完成取结果，否则判断下一个任务是否完成
		if (future.isDone() && !future.isCancelled()){
		//获取结果
		                        Integer i = future.get();
		//任务完成移除任务
		iterable.remove();
		}
	}
}
 
总结:
 
将线程执行结果存入FutureList里面,然后轮询这个list,
通过迭代器获取到对应的Future,用future.get()来获取结果。
 
建议：
 
这种方式取结果,如果没有取到会产生阻塞,直到取到结果才会执行下一个future.get(),
所以适用于结果集要保持顺序的情况。
 
二.ExecutorService+FutureTask
 
原理:
 
是接口RunnableFuture的唯一实现类。类图如下
 
 
如上图，可见RunnableFuture接口继承自Future+Runnable:
 所以又有run方法,又有Future接口的get等方法。
 
1.Runnable接口，可开启单个线程执行。
 2.Future接口，可接受Callable接口的返回值，futureTask.get()阻塞获取结果。
 
FutureTask的构造方法有两种，其实最终都是赋值callable。如下图
 

 
 
demo:
 
(1)、创建线程池
 
ExecutorService exs = Executors.newFixedThreadPool(10);
 
(2)、创建FutureTask任务结果集list
 
List<FutureTask<Integer>> futureList = new 	ArrayList<FutureTask<Integer>>();
 
(3)、提交任务，每个任务结果返回到FutureList里面
 
 for(int i=0;i<10;i++){
    FutureTask<Integer> futureTask = new FutureTask<Integer>(new CallableTask(i+1));
       //Future特性
       futureList.add(futureTask);
  }
 
(4)、结果归集，用迭代器遍历futureList,高速轮询，任务完成就移除
 
while(futureList.size()>0){

	Iterator<FutureTask<Integer>> iterable = futureList.iterator();
	
	while(iterable.hasNext()){
	Future<Integer> future = iterable.next();
		if (future.isDone()&& !future.isCancelled()) {
		Integer i = future.get();
		//任务完成移除任务
		iterable.remove();
		}
	}
}
 
总结:
 
FutureTask和Future其实没太大的区别,
只不过Future的方式是需要用线程池提交任务(exs.submit(new CallableTask(i + 1)))

FutureTask则可以用构造方法提交任务(new FutureTask<Integer>(new CallableTask(i+1));)

同样是取结果是按顺序阻塞的,所以我任务FutureTask这东西有些鸡肋。
 
建议：
 
多线程并发执行并结果归集，这里多套一层FutureTask比较鸡肋（直接返回Future简单明了）不建议使用。
 
三、CompletionService+Future：
 
原理:
 
1、使用内部阻塞队列的take()

CompletionService.take()方法,可以按照任务执行完成的顺序获取到对应的FutureTask,
也就是谁先执行完谁先返回,不会按照谁先开始执行谁先返回的顺序,因此也就不会造成阻塞。

2、使用future的阻塞获取方法future.get(),按照提交顺序返回结果,也就是会造成阻塞。
 
demo:
 
(1)、创建线程池
 
ExecutorService exs = Executors.newFixedThreadPool(5);
 
(2)、定义CompletionService线程服务
 
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(exs);  
 
(3)、创建FutureList列表
 
 List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
 
(4)、提交任务，每个任务结果返回到FutureList里面
 
for(int i=0;i<taskCount;i++){
  futureList.add(completionService.submit(new Task(i+1)));
}
 
(5)、结果归集
 
方法一:
 
使用future的阻塞获取方法future.get(),按照提交顺序返回结果,也就是会造成阻塞。

for (Future<Integer> future : futureList) {
  Integer result = future.get();
}
 
方法二:
 
使用内部阻塞队列的take(),也就是谁先执行完谁先返回,不会造成阻塞。

Integer result = completionService.take().get();
 
总结:
 
可以按照提交顺序阻塞返回结果,也可以按照执行完成顺序非阻塞返回结果。
 
建议：
 
能按照完成先后排序，建议如果有排序需求的优先使用。
只是多线程并发执行任务结果归集(非阻塞,按照任务完成顺序返回)，也可以使用。
 
四、CompletableFuture：
 
原理：
 
JDK1.8才新加入的一个实现类，实现了Future, CompletionStage2个接口。
 
实现CompletionStage接口是为了实现流式编程。
 
CompletableFuture中4个异步执行任务静态方法：
 
 
supplyAsync用于有返回值的任务
runAsync则用于没有返回值的任务
Executor参数可以手动指定线程池，否则默认ForkJoinPool.commonPool()系统级公共线程池,
注意：这些线程都是Daemon线程，主线程结束Daemon线程不结束，只有JVM关闭时，生命周期终止。
 
组合CompletableFuture：
 
thenCombine()：
 
先完成当前CompletionStage和other 2个CompletionStage任务，
 然后把结果传参给BiFunction进行结果合并操作。
 
 
thenCompose()：
 
第一个CompletableFuture执行完毕后，
 传递给下一个CompletionStage作为入参进行操作。
 
 
demo:
 
CompletableFuture  自带多任务组合方法allOf和anyOf
allOf是等待所有任务完成，构造后CompletableFuture完成。
anyOf是只要有一个任务完成，构造后CompletableFuture就完成。
 
方式一：循环创建CompletableFuture list,调用sequence()组装返回一个有返回值的CompletableFuture，返回结果get()获取
 
方式二：全流式处理转换成CompletableFuture[]+allOf组装成一个无返回值CompletableFuture，join等待执行完毕。返回结果whenComplete获取。—》推荐
 
(1)、创建线程池
 
ExecutorService exs = Executors.newFixedThreadPool(10);
 
(2)、创建CompletableFuture集合
 
List<CompletableFuture<String>> futureList = new ArrayList<>();
 
(3)、取结果
 
方式一:
 
循环创建CompletableFuture list,调用sequence()组装返回一个有返回值的CompletableFuture，返回结果get()获取
 
for(int i=0;i<taskList.size();i++){
              final int j=i;
              //异步执行
              CompletableFuture<String> future = 
  			  CompletableFuture.supplyAsync(()->calc(taskList.get(j)), exs)
  	      	  .thenApply(e->Integer.toString(e))
              //如需获取任务完成先后顺序，此处代码即可
              .whenComplete((v, e) -> {
	               System.out.println("任务"+v+"完成!result="+v+"，异常 e="+e+","+new Date());
	            });
	               futureList.add(future);
            }
	   		 //流式获取结果：此处是根据任务添加顺序获取的结果
            list = sequence(futureList).get();
 
方式二：
 
全流式处理,转换成CompletableFuture[]+组装成一个无返回值CompletableFuture，
 join等待执行完毕。返回结果whenComplete获取。
 
CompletableFuture[] cfs = taskList.stream().map(object-> CompletableFuture.supplyAsync(()->calc(object), exs)
                      .thenApply(h->Integer.toString(h))
                      //如需获取任务完成先后顺序，此处代码即可
                      .whenComplete((v, e) -> {
                        System.out.println("任务"+v+"完成!result="+v+"，
                        异常 e="+e+","+new Date());
 						list2.add(v);
                     })).toArray(CompletableFuture[]::new);
              //等待总任务完成，但是封装后无返回值，必须自己whenComplete()获取
              CompletableFuture.allOf(cfs).join();
 
总结:
 
方法一是将任务全部存入到List<CompletableFuture<String>>里面,
然后利用sequence(futureList).get()方法按照添加顺序获取结果,也就是whenComplete里面的v。

方法二是将任务list流式处理,生成一个CompletableFuture[] 数组,
然后通过 CompletableFuture.allOf(cfs).join()方法来获取结果集。
 
建议:
 
CompletableFuture满足并发执行，顺序完成可按任务执行完成顺序获取的目标。
而且支持每个任务的异常返回，配合流式编程，用起来速度飞起。JDK源生支持，API丰富，推荐使用。
 
 
五、CompletableFuture方法详解
 
(1)、主动完成计算
 
 
getNow有点特殊，如果结果已经计算完则返回结果或者抛出异常，否则返回给定的valueIfAbsent值。

join返回计算的结果或者抛出一个unchecked异常(CompletionException)，
 
(2)、创建CompletableFuture对象。
 
 
Async代表异步执行,run代表执行runable接口的start方法执行,所以无返回值
supply开头的是执行的callable接口的call方法,有返回值。

如果不指定线程池,就默认用ForkJoinPool.commonPool()作为它的线程池执行异步代码。

使用lambda表达式实现异步任务:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
//长时间的计算任务
return "·00";
});
 
(3)、计算结果完成时的处理
 
当CompletableFuture的计算结果完成，或者抛出异常的时候，我们可以执行特定的Action。主要是下面的方法：
 
 
Async代表异步,不加代表同步

这几个方法的返回值都是CompletableFuture

whenComplete就是写执行逻辑的回调函数

exceptionally方法返回一个新的CompletableFuture，当原始的CompletableFuture抛出异常的时候，就会触发这个CompletableFuture的计算,也就是这个exceptionally方法用来处理异常的情况。
 
(4)、转换
 
 
当原来的CompletableFuture计算完后，将结果传递给函数fn，
将fn的结果作为新的CompletableFuture计算结果
因此它的功能相当于将CompletableFuture<T>转换成CompletableFuture<U>。
也就是把上一个CompletableFuture的计算结果传入fn进行转换。


这三个函数的区别和上面介绍的一样，不以Async结尾的方法由原来的线程计算，
以Async结尾的方法由默认的线程池ForkJoinPool.commonPool()或者指定的线程池executor运行。
Java的CompletableFuture类总是遵循这样的原则。


与handle方法的区别在于handle方法会处理正常计算值和异常，因此它可以屏蔽异常，
避免异常继续抛出。而thenApply方法只是用来处理正常值，因此一旦有异常就会抛出。
 
(5)、纯消费(执行Action)
 
 
无返回值类型的方法。
 
(6)、组合
 
 
这一组方法接受一个Function作为参数,这个Function的输入参数是当前的CompletableFuture的计算值,
返回结果将是一个新的CompletableFuture。

也就是把钱一个CompletableFuture的结果作为参数传入带下一个CompletableFuture中执行。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
return 100;
});

CompletableFuture<String> f = future.thenCompose( i -> {
return CompletableFuture.supplyAsync(() -> {
return (i * 10) + "";
});
});
 
 
另外一种组合方法,thenCombine,两个CompletionStage是并行执行的，
它们之间并没有先后依赖顺序，other并不会等待先前的CompletableFuture执行完毕后再执行。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
return 100;
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
return "abc";
});

CompletableFuture<String> f = future.thenCombine(future2, (x,y) -> y + "-" + x);

System.out.println(f.get()); //abc-100
 
(7)、辅助方法
 
allOf 和 anyOf
 
 用来组合多个CompletableFuture
 
allOf方法是当所有的CompletableFuture都执行完后执行计算。
anyOf方法是当任意一个CompletableFuture执行完后就会执行计算，计算的结果相同。

 
Java多线程面试问题
 
1. 进程和线程之间有什么不同？
 
一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。
 
2. 多线程编程的好处是什么？
 
在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。
 
3. 用户线程和守护线程有什么区别？
 
当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。
 
4. 我们如何创建一个线程？
 
有两种创建线程的方法：一是实现Runnable接口，然后将它传递给Thread的构造函数，创建一个Thread对象；二是直接继承Thread类。若想了解更多可以阅读这篇关于如何在Java中创建线程的文章。
 
5. 有哪些不同的线程生命周期？
 
当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。读这篇文章可以了解更多关于线程生命周期的知识。
 
6. 可以直接调用Thread类的run()方法么？
 
当然可以，但是如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，为了在新的线程中执行我们的代码，必须使用Thread.start()方法。
 
7. 如何让正在运行的线程暂停一段时间？
 
我们可以使用Thread类的Sleep()方法让线程暂停一段时间。需要注意的是，这并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，并且根据线程调度，它将得到执行。
 
8. 你对线程优先级的理解是什么？
 
每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。
 
9. 什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)？
 
线程调度器是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。
 
10. 在多线程中，什么是上下文切换(context-switching)？
 
上下文切换是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。
 
11. 你如何确保main()方法所在的线程是Java程序最后结束的线程？
 
我们可以使用Thread类的joint()方法来确保所有程序创建的线程在main()方法退出前结束。这里有一篇文章关于Thread类的joint()方法。
 
12.线程之间是如何通信的？
 
当线程间是可以共享资源时，线程间通信是协调它们的重要的手段。Object类中wait()\notify()\notifyAll()方法可以用于线程间通信关于资源的锁的状态。点击这里有更多关于线程wait, notify和notifyAll.
 
13.为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object类里？
 
Java的每个对象中都有一个锁(monitor，也可以成为监视器) 并且wait()，notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分，这样Java的每一个类都有用于线程间通信的基本方法
 
14. 为什么wait(), notify()和notifyAll()必须在同步方法或者同步块中被调用？
 
当一个线程需要调用对象的wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的notify()方法。同样的，当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用。
 
15. 为什么Thread类的sleep()和yield()方法是静态的？
 
Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作，并避免程序员错误的认为可以在其他非运行线程调用这些方法。
 
16.如何确保线程安全？
 
在Java中可以有很多方法来保证线程安全——同步，使用原子类(atomic concurrent classes)，实现并发锁，使用volatile关键字，使用不变类和线程安全类。在线程安全教程中，你可以学到更多。
 
17. volatile关键字在Java中有什么作用？
 
当我们使用volatile关键字去修饰变量的时候，所以线程都会直接读取该变量并且不缓存它。这就确保了线程读取到的变量是同内存中是一致的。
 
18. 同步方法和同步块，哪个是更好的选择？
 
同步块是更好的选择，因为它不会锁住整个对象(当然你也可以让它锁住整个对象)。同步方法会锁住整个对象，哪怕这个类中有多个不相关联的同步块，这通常会导致他们停止执行并需要等待获得这个对象上的锁。
 
19.如何创建守护线程？
 
使用Thread类的setDaemon(true)方法可以将线程设置为守护线程，需要注意的是，需要在调用start()方法前调用这个方法，否则会抛出IllegalThreadStateException异常。
 
20. 什么是ThreadLocal?
 
ThreadLocal用于创建线程的本地变量，我们知道一个对象的所有线程会共享它的全局变量，所以这些变量不是线程安全的，我们可以使用同步技术。但是当我们不想使用同步的时候，我们可以选择ThreadLocal变量。
 
每个线程都会拥有他们自己的Thread变量，它们可以使用get()\set()方法去获取他们的默认值或者在线程内部改变他们的值。ThreadLocal实例通常是希望它们同线程状态关联起来是private static属性。在ThreadLocal例子这篇文章中你可以看到一个关于ThreadLocal的小程序。
 
21. 什么是Thread Group？为什么不建议使用它？
 
ThreadGroup是一个类，它的目的是提供关于线程组的信息。
 
ThreadGroup API比较薄弱，它并没有比Thread提供了更多的功能。它有两个主要的功能：一是获取线程组中处于活跃状态线程的列表；二是设置为线程设置未捕获异常处理器(ncaught exception handler)。但在Java 1.5中Thread类也添加了setUncaughtExceptionHandler(UncaughtExceptionHandler eh) 方法，所以ThreadGroup是已经过时的，不建议继续使用。
 
22. 什么是Java线程转储(Thread Dump)，如何得到它？
 
线程转储是一个JVM活动线程的列表，它对于分析系统瓶颈和死锁非常有用。有很多方法可以获取线程转储——使用Profiler，Kill -3命令，jstack工具等等。我更喜欢jstack工具，因为它容易使用并且是JDK自带的。由于它是一个基于终端的工具，所以我们可以编写一些脚本去定时的产生线程转储以待分析。读这篇文档可以了解更多关于产生线程转储的知识。
 
23. 什么是死锁(Deadlock)？如何分析和避免死锁？
 
死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。
 
分析死锁，我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id，用这个id我们可以找出哪些线程已经拥有了它的对象锁。
 
避免嵌套锁，只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法，阅读这篇文章去学习如何分析死锁。
 
24. 什么是Java Timer类？如何创建一个有特定时间间隔的任务？
 
java.util.Timer是一个工具类，可以用于安排一个线程在未来的某个特定时间执行。Timer类可以用安排一次性任务或者周期任务。
 
java.util.TimerTask是一个实现了Runnable接口的抽象类，我们需要去继承这个类来创建我们自己的定时任务并使用Timer去安排它的执行。
 
25. 什么是线程池？如何创建一个Java线程池？
 
一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行的任务的队列。
 
java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。线程池例子展现了如何创建和使用线程池，或者阅读ScheduledThreadPoolExecutor例子，了解如何创建一个周期任务。
 
Java并发面试问题
 
1. 什么是原子操作？在Java Concurrency API中有哪些原子类(atomic classes)？
 
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
 
int++并不是一个原子操作，所以当一个线程读取它的值并加1时，另外一个线程有可能会读到之前的值，这就会引发错误。
 
为了解决这个问题，必须保证增加操作是原子的，在JDK1.5之前我们可以使用同步技术来做到这一点。到JDK1.5，java.util.concurrent.atomic包提供了int和long类型的装类，它们可以自动的保证对于他们的操作是原子的并且不需要使用同步。可以阅读这篇文章来了解Java的atomic类。
 
2. Java Concurrency API中的Lock接口(Lock interface)是什么？对比同步它有什么优势？
 
Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
 
它的优势有：可以使锁更公平
 
可以使线程在等待锁的时候响应中断
 
可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间
 
可以在不同的范围，以不同的顺序获取和释放锁
 
3. 什么是Executors框架？
 
Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。Executor框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架。
 
无限制的创建线程会引起应用程序内存溢出。所以创建一个线程池是个更好的的解决方案，因为可以限制线程的数量并且可以回收再利用这些线程。利用Executors框架可以非常方便的创建一个线程池，阅读这篇文章可以了解如何使用Executor框架创建一个线程池。
 
4. 什么是阻塞队列？如何使用阻塞队列来实现生产者-消费者模型？
 
java.util.concurrent.BlockingQueue的特性是：当队列是空的时，从队列中获取或删除元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。
 
阻塞队列不接受空值，当你尝试向队列中添加空值的时候，它会抛出NullPointerException。
 
阻塞队列的实现都是线程安全的，所有的查询方法都是原子的并且使用了内部锁或者其他形式的并发控制。
 
BlockingQueue 接口是java collections框架的一部分，它主要用于实现生产者-消费者问题。
 
5. 什么是Callable和Future?
 
Java 5在concurrency包中引入了java.util.concurrent.Callable 接口，它和Runnable接口很相似，但它可以返回一个对象或者抛出一个异常。
 
Callable接口使用泛型去定义它的返回类型。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，我们必须等待它返回的结果。java.util.concurrent.Future对象为我们解决了这个问题。在线程池提交Callable任务后返回了一个Future对象，使用它我们可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法让我们可以等待Callable结束并获取它的执行结果。
 
6. 什么是FutureTask?
 
FutureTask是Future的一个基础实现，我们可以将它同Executors使用处理异步任务。通常我们不需要使用FutureTask类，单当我们打算重写Future接口的一些方法并保持原来基础的实现是，它就变得非常有用。我们可以仅仅继承于它并重写我们需要的方法。阅读Java FutureTask例子，学习如何使用它。
 
7.什么是并发容器的实现？
 
Java集合类都是快速失败的，这就意味着当集合被改变且一个线程在使用迭代器遍历集合的时候，迭代器的next()方法将抛出ConcurrentModificationException异常。
 
并发容器支持并发的遍历和并发的更新。
 
主要的类有ConcurrentHashMap, CopyOnWriteArrayList 和CopyOnWriteArraySet，阅读这篇文章了解如何避免ConcurrentModificationException。
 
8. Executors类是什么？
 
Executors为Executor，ExecutorService，ScheduledExecutorService，ThreadFactory和Callable类提供了一些工具方法。
 
Executors可以用于方便的创建线程池
 
9.为什么说ConcurrentHashMap是弱一致性的？以及为何多个线程并发修改ConcurrentHashMap时不会报ConcurrentModificationException？
 
作者：海子
 
本博客中未标明转载的文章归作者海子和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

 
1. 禁止同一个 JobDetail 中的多个实例并发执行
 
Quartz 定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行，如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。
 
禁止并发执行的意思并不是不能同时执行多个 Job，而是不能并发执行同一个 Job Definition(由 JobDetail 定义)，但是可以同时执行多个不同的 JobDetail，举例说明，我们有一个 Job 类，叫做 SayHelloJob，并在这个 Job 上加了 @DisallowConcurrentExecution 注解，然后在这个 Job上 定义了很多个 JobDetail，如 sayHelloToJoeJobDetail，sayHelloToMikeJobDetail，那么当 scheduler 启动时，不会并发执行多个 sayHelloToJoeJobDetail 或者 sayHelloToMikeJobDetail，但可以同时执行 sayHelloToJoeJobDetail 跟 sayHelloToMikeJobDetail。
 
1.1 使用 Spring 整合 Quartz 时
 
Spring 配置文件中加入：
 
1.2 Quartz 原生使用时
 
当不使用 Spring 的时候就需要在 Job 的实现类上加 @DisallowConcurrentExecution 的注解。
 
2. 同一个 JobDetail 中多个实例的数据共享
 
@PersistJobDataAfterExecution 是用在 Job 实现类上，表示一个有状态的任务，意思是当正常执行完 Job 后，JobDataMap 中的数据应该被改动，以被下一次调用时用。
 
注意：当使用 @PersistJobDataAfterExecution 注解时，为了避免并发时，存储数据造成混乱，强烈建议把 @DisallowConcurrentExecution 注解也加上。
 
3. 示例
 
假设定时任务的时间间隔为 3 秒，但 job 执行时间是 10 秒。当设置 @DisallowConcurrentExecution 以后程序会等任务执行完毕后再去执行，否则会在 3 秒时再启动新的线程执行。
 
当设置 @PersistJobDataAfterExecution 时，在执行完 Job 的 execution 方法后保存 JobDataMap 当中固定数据，以便任务在重复执行的时候具有相同的 JobDataMap；在默认情况下也就是没有设置 @PersistJobDataAfterExecution 的时候每个 job 都拥有独立 JobDataMap。
 
任务类：
 
package org.quartz.examples;
 
import org.quartz.*;
 
import java.util.Date;
 
@PersistJobDataAfterExecution
 
@DisallowConcurrentExecution
 
public class TaskJob implements Job {
 
public static final String NUM_EXECUTIONS = "NumExecutions";
 
public static final String EXECUTION_DELAY = "ExecutionDelay";
 
/**
 
* 静态变量可以保持工作状态，但无法达到预期效果
 
*/
 
private static int _staticCounter = 0;
 
/**
 
* Quartz 每次执行作业时都会重新实例化，非静态变量无法保持工作状态
 
*/
 
private int _counter = 0;
 
/**
 
* 需要一个公共的空构造方法，以便 scheduler 随时实例化 job
 
*/
 
public TaskJob() {
 
}
 
/**
 
* 该方法实现需要执行的任务
 
*/
 
public void execute(JobExecutionContext context) throws JobExecutionException {
 
System.err.println("---> " + context.getJobDetail().getKey() + " 运行中[" + new Date() + "]");
 
JobDataMap map = context.getJobDetail().getJobDataMap();
 
int executeCount = 0;
 
if (map.containsKey(NUM_EXECUTIONS)) {
 
executeCount = map.getInt(NUM_EXECUTIONS);
 
}
 
// 增量计数并将其存储回 JobDataMap，这样可以适当保持工作状态
 
executeCount++;
 
map.put(NUM_EXECUTIONS, executeCount);
 
// 只要有任务执行都会递增，无法达到预期效果
 
_staticCounter++;
 
// 本地变量递增加，但实际上无法保持工作状态
 
_counter++;
 
long delay = 5000L;
 
if (map.containsKey(EXECUTION_DELAY)) {
 
delay = map.getLong(EXECUTION_DELAY);
 
}
 
try {
 
// 模拟一个耗时的 job
 
Thread.sleep(delay);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
}
 
System.err.println(context.getJobDetail().getKey() + " 的静态变量 _staticCounter 为：" + _staticCounter + "，非静态变量 scheduler 为：" + _counter);
 
System.err.println(context.getJobDetail().getKey() + " 完成了(" + executeCount + ")次 
 
}
 
}
 
任务调度类：
 
package org.quartz.examples;
 
import org.quartz.*;
 
import org.quartz.impl.StdSchedulerFactory;
 
import java.util.Date;
 
public class Executer {
 
public void run() throws Exception {
 
// 通过 schedulerFactory 获取一个调度器
 
SchedulerFactory sf = new StdSchedulerFactory();
 
Scheduler sched = sf.getScheduler();
 
// 创建 jobDetail 实例，绑定 Job 实现类
 
// 指明 job 的名称，所在组的名称，以及绑定 job 类
 
JobDetail job1 = JobBuilder.newJob(TaskJob.class)
 
.withIdentity("statefulJob1", "group1")
 
// 给定的键-值对添加到 JobDetail 的 JobDataMap 中
 
.usingJobData(TaskJob.EXECUTION_DELAY, 10000L).build();
 
// 定义调度触发规则，先立即执行一次，然后每隔 3 秒执行一次
 
SimpleTrigger trigger = TriggerBuilder.newTrigger()
 
.withIdentity("trigger1", "group1")
 
.startNow()
 
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
 
.withIntervalInSeconds(3)
 
.repeatForever())
 
.build();
 
// 把作业和触发器注册到任务调度中
 
Date firstRunTime = sched.scheduleJob(job1, trigger);
 
System.out.println(job1.getKey() + " 开始运行于：" + firstRunTime + "，重复：" + trigger.getRepeatCount() + " 次，每次间隔 "
 
+ trigger.getRepeatInterval() / 1000 + " 秒");
 
// 任务 job1 方法中拿到的 JobDataMap 的数据是共享的
 
// 这里要注意一个情况： 就是 JobDataMap 的数据共享只针对一个 job1 任务
 
// 如果在下面在新增加一个任务 那么他们之间是不共享的，比如下面的 job2
 
// 创建第二个 JobDetail 实例
 
JobDetail job2 = JobBuilder.newJob(TaskJob.class)
 
.withIdentity("statefulJob2", "group1")
 
// 给定的键-值对添加到 JobDetail 的 JobDataMap 中
 
.usingJobData(TaskJob.EXECUTION_DELAY, 10000L)
 
.build();
 
// 定义调度触发规则，先立即执行一次，然后每隔 3 秒执行一次
 
trigger = TriggerBuilder.newTrigger()
 
.withIdentity("trigger2", "group1")
 
.startNow()
 
.withSchedule(SimpleScheduleBuilder.simpleSchedule().
 
withIntervalInSeconds(3)
 
.repeatForever()
 
// 指定失效时的策略
 
.withMisfireHandlingInstructionNowWithExistingCount())
 
.build();
 
// 这个 job2 与 job1 执行的 JobDataMap 不共享
 
// 把作业和触发器注册到任务调度中
 
firstRunTime = sched.scheduleJob(job2, trigger);
 
System.out.println(job2.getKey() + " 开始运行于：" + firstRunTime + "，重复：" + trigger.getRepeatCount() + " 次，每次间隔 "
 
+ trigger.getRepeatInterval() / 1000 + " 秒");
 
// 启动计划程序(实际上直到调度器已经启动才会开始运行)
 
sched.start();
 
// 等待 60 秒，使我们的 job 有机会执行
 
Thread.sleep(60000);
 
// 等待作业执行完成时才关闭调度器
 
sched.shutdown(true);
 
SchedulerMetaData metaData = sched.getMetaData();
 
System.out.println("一共运行了：" + metaData.getNumberOfJobsExecuted() + " 个任务");
 
}
 
public static void main(String[] args) throws Exception {
 
Executer example = new Executer();
 
example.run();
 
}
 
}
 
运行结果：
 
group1.statefulJob1 开始运行于：Wed Apr 19 17:04:22 CST 2017，重复：-1 次，每次间隔 3 秒
 
group1.statefulJob2 开始运行于：Wed Apr 19 17:04:22 CST 2017，重复：-1 次，每次间隔 3 秒
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:22 CST 2017]
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:22 CST 2017]
 
group1.statefulJob2 的静态变量 _staticCounter 为：2，非静态变量 scheduler 为：1
 
group1.statefulJob1 的静态变量 _staticCounter 为：2，非静态变量 scheduler 为：1
 
group1.statefulJob2 完成了(1)次 
 
group1.statefulJob1 完成了(1)次 
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:32 CST 2017]
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:32 CST 2017]
 
group1.statefulJob1 的静态变量 _staticCounter 为：4，非静态变量 scheduler 为：1
 
group1.statefulJob1 完成了(2)次 
 
group1.statefulJob2 的静态变量 _staticCounter 为：4，非静态变量 scheduler 为：1
 
group1.statefulJob2 完成了(2)次 
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:42 CST 2017]
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:42 CST 2017]
 
group1.statefulJob2 的静态变量 _staticCounter 为：6，非静态变量 scheduler 为：1
 
group1.statefulJob1 的静态变量 _staticCounter 为：6，非静态变量 scheduler 为：1
 
group1.statefulJob1 完成了(3)次 
 
group1.statefulJob2 完成了(3)次 
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:52 CST 2017]
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:52 CST 2017]
 
group1.statefulJob2 的静态变量 _staticCounter 为：8，非静态变量 scheduler 为：1
 
group1.statefulJob2 完成了(4)次 
 
group1.statefulJob1 的静态变量 _staticCounter 为：8，非静态变量 scheduler 为：1
 
group1.statefulJob1 完成了(4)次 
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:05:02 CST 2017]
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:05:02 CST 2017]
 
group1.statefulJob2 的静态变量 _staticCounter 为：10，非静态变量 scheduler 为：1
 
group1.statefulJob1 的静态变量 _staticCounter 为：10，非静态变量 scheduler 为：1
 
group1.statefulJob2 完成了(5)次 
 
group1.statefulJob1 完成了(5)次 
 
---> group1.statefulJob1 运行中[Wed Apr 19 17:05:12 CST 2017]
 
---> group1.statefulJob2 运行中[Wed Apr 19 17:05:12 CST 2017]
 
group1.statefulJob2 的静态变量 _staticCounter 为：12，非静态变量 scheduler 为：1
 
group1.statefulJob2 完成了(6)次 
 
group1.statefulJob1 的静态变量 _staticCounter 为：12，非静态变量 scheduler 为：1
 
group1.statefulJob1 完成了(6)次 
 
一共运行了：12 个任务
 
4. 参考
 
PS：本文针对的 Quartz 版本为 Quartz 2.2.3。官方下载地址：Quartz 2.2.3 .tar.gz