一、为什么要用到并发
充分利用多核CPU的计算能力
方便进行业务拆分，提升应用性能
二、并发编程有哪些缺点
频繁的上下文切换
时间片是CPU分配给各个线程的时间，因为时间非常短，所以CPU不断通过切换线程，让我们觉得是不断执行的，时间片一般是几十毫秒。而每次切换时，需要保存当前的状态，以便能够进行回复当期状态。而这个切换是非常损耗性能，过于频繁反而无法发挥出多线程编程的优势。通常减少上下文切换可以采用无锁并发编程，CAS算法，使用最少的线程和使用协程。
比如：悲观锁就会导致频繁的上下文切换，而频繁的上下文切换可能无法发挥出多线程编程的优势
无锁并发编程
可以参照jdk1.7分段锁的思想，不同的线程处理不同的数据，这样在多线程竞争的条件下，可以减少上下文切换的时间
CAS算法
利用Atomic下使用CAS（compare and swap）算法来更新数据，使用了乐观锁，可以有效的减少一部分不必要的锁竞争带来的上下文切换。
使用最少的线程
避免创建不必要的线程，比如任务很少，但是创建了很多的线程，这样会造成大量的线程都处于等待状态。
线程安全--死锁
多线程编程中最难以把握的就是临界区线程安全问题，稍微不注意就会出现死锁的情况，一旦产生死锁就会造成系统功能不可用。
避免死锁
-
- 避免一个线程同时获得多个锁
- 避免一个线程在锁内占有多个资源，尽量保证每个所只占有一个资源
- 尝试使用定时锁，使用lock.tryLock(TimeOut)，当超时等待时当前线程不会阻塞
- 对于数据库，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况
三、并行和并发
并发指的是多个任务交替执行，而并行指的是真正意义上的同时进行
实际上，如果系统内只有一个CPU，而使用多线程时，那么真实系统环境下不能并行，只能通过切换时间片的方式交替进行，而成为并发执行任务。真正的并行也只能出现在拥有多个CPU的系统中。
四、同步和异步
同步和异步通常用来形容一次方法的调用
同步方法调用一开始，调用者必须等待被调用的方法结束后，调用者后面的代码才能执行。而异步调用，指的是，调用者不管被调用方法是否完成，都会继续执行后面的代码，当被调用的方法完成后会通知调用者。
五、阻塞和非阻塞
阻塞和非阻塞常用来形容多线程间的相互影响。
比如一个线程占有了临界区资源，那么其他线程需要这个资源就必须进行等待该资源的释放，会导致等待的线程挂起，这种情况就是阻塞，而非阻塞就恰好相反，它强调没有一个线程可以阻塞其他线程，所有的线程都会尝试的往前运行
六、线程的临界区资源
临界区用来表示一种公共资源或者说共享数据，可以被多个线程使用，但是每一个线程使用时，一旦临界区资源被一个线程占有，那么其它线程必须等待。
七、新建线程有哪几种方式
一个Java线程从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但是实际上Java程序天生就是一个多线程程序，包含了：
- 分发出路发送给JVM信号的线程
- 调用对象的finalize方法的线程
- 清除Reference的线程
- main线程，用户程序的入口
三种方式（有三种方式实现，JDK源码中标明只有两种方式）
1、继承Thread类，重写run方法
2、实现Runnable接口
3、实现Callable接口
public class NewThread {
/*扩展自Thread类*/
private static class UseThread extends Thread{
@Override
public void run() {
super.run();
// do my work;
System.out.println("I am extendec Thread");
}
}
/*实现Runnable接口*/
private static class UseRunnable implements Runnable{
@Override
public void run() {
// do my work;
System.out.println("I am implements Runnable");
}
}
public static void main(String[] args)
throws InterruptedException, ExecutionException {
UseThread useThread = new UseThread();
useThread.start();
useThread.start();
UseRunnable useRunnable = new UseRunnable();
new Thread(useRunnable).start();
}
}
public class UseFuture {
/*实现Callable接口，允许有返回值*/
private static class UseCallable implements Callable<Integer>{
private int sum;
@Override
public Integer call() throws Exception {
for(int i=0 ;i<5000;i++){
if(Thread.currentThread().isInterrupted()) {return null;
}
sum=sum+i;
System.out.println("sum="+sum);
} return sum;
}
}
public static void main(String[] args)
throws InterruptedException, ExecutionException {
UseCallable useCallable = new UseCallable();
//包装
FutureTask<Integer> futureTask = new FutureTask<>(useCallable);
Random r = new Random();
new Thread(futureTask).start();
Thread.sleep(1);
if(r.nextInt(100)>50){
System.out.println("Get UseCallable result = "+futureTask.get());
}else{
futureTask.cancel(true);
}
}
}
八、线程的转换状态
- 线程创建之后调用start()方法开始运行，当调用wait()，join()，LockSupport.lock()方法线程会进入到WAITING状态。
- 而同样的wait(long timeout)，sleep(long time)，join()，LockSupport.parkNamos()，LockSupport.parkUtil()增加了超时等待的功能，也就是调用这些方法后线程会进入TIME_WAITING状态
- 当超时等待时间到达后线程会切换到RUNNABLE的状态，另外当WAITING和TIME_WAITING状态是可以通过notify/notifyAll方法使线程转换到RUNNABLE状态
- 当线程出现资源竞争时，即等待获取锁的时候，线程会进入到BLOCKED阻塞状态
- 当线程获取锁时，线程进入到RUNNABLE状态
- 线程运行结束，线程进入到TERMINATED状态，状态转换可以说是线程的声明周期
另外需要注意的是：
当线程进入到synchronized方法或者synchronize的代码块的时候，线程切换的是BLOCKED状态，而使用lock进行加锁的时候线程切换的是WAITING或者TIME_WAITING状态，因为lock会调用LockSupport的方法
九、中断标志位--interrupted
中断可以理解为线程的一个标志位，它代表了一个运行中的线程是否被其他线程进行了中断操作。
中断好比其他线程对该线程打了一个招呼。其他线程可以调用该线程的interrupt()方法对其进行中断操作，同时该线程可以调用isInterrupted()来感知其他线程对自身的中断操作，从而做出响应。
另外，同样可以调用Thread的静态方法interrupted()对当前线程进行中断操作，该方法会清除中断标志位。
需要注意的是，当抛出interruptedExection时候，会清除中断标志位，也就是说在调用isInterrupted时会返回false。
十、join
如果一个线程实例A执行了threadB.join()，其含义是：当前线程A会等待线程threadB线程终止后threadA才会继续执行
关于join方法一共提供了如下这些方法
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
join(millis);
}
public final void join() throws InterruptedException {
join(0);
}
Thread类出了提供join()方法外，另外还提供了超时等待的方法，如果线程threadB在等待的时间内还没有结束的话，threadA会在超时之后继续执行。join方法源码的关键是
while (isAlive()) {
wait(0);
}
可以看出来当前等待对象threasA会一直阻塞，知道被等待对象threadB结束后即isAlive()返回false的时候才会结束while循环，当天threadB退出时会调用notifyAll方法通知所有的等待线程。
十一、sleep和wait
public static native void sleep(long millis) throws InterruptedException;
该方法显然是Thread的静态方法，很显然它是让当前线程按照指定的时间休眠，其休眠时间的精度取决于处理器的计时器和调度器
需要注意的是如果当前线程获得了锁，sleep方法并不会失去锁。sleep方法经常拿来和object.wait()方法进行比较，这也是面试经常被问到的地方
sleep()和wait()的区别
1.sleep方法是threa的静态方法，而wait是objectshilde方法；
2、wait方法必须要在同步方法或者同步块中调用，也就是必须获得对象锁，而sleep方法没有这个限制，可以在任何地方使用
3、wait方法会释放占有的对象锁，使线程进入到等待池中，等待下一次获取资源。而sleep方法只是会让出CPU并不会释放掉对象锁
4、sleep方法在休眠时间达到后如果再次获取CPU时间片就会继续执行，而wait方法必须等到notify/notifyAll通知后，才会离开等待池，并且再次获取CPU时间片才会继续执行
十二、yield
public static native void yield();
1、这是一个thread的静态方法
2、一旦执行，它会是当前线程让出CPU，但是，需要注意的是，让出的CPU并不是代表当前线程不在运行了，吐过在下一次竞争中，又获得CPU时间片当前线程依旧会继续运行。另外让出的时间片智慧分配给当前相同优先级的线程
3、需注意的是sleep和yield方法，同样都是当前线程会交出处理器资源，而它们不同的是，sleep交出来的时间片其他线程都可以去竞争，也就是说都有机会获得当前线程让出的时间片。而yield方法只允许与当前具有相同优先级的线程能够获得释放出来的CPU时间片。
十三、线程的优先级
在 Java 线程中，通过一个整型成员变量 priority 来控制优先级，优先级的范围从 1~10，在线程构建的时候可以通过 setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配时间片的数量要多于优先级低的线程。
设置线程优先级时，针对频繁阻塞（休眠或者 I/O 操作）的线程需要设置较高优先级，而偏重计算（需要较多 CPU 时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。在不同的 JVM 以及操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。
十四、守护线程
Daemon（守护）线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个 Java 虚拟机中不存在非 Daemon 线程的时候，Java 虚拟机将会退出。可以通过调用 Thread.setDaemon(true)将线程设置为 Daemon 线程。我们一般用不上，比如垃圾回收线程就是 Daemon 线程。
Daemon 线程被用作完成支持性工作，但是在 Java 虚拟机退出时 Daemon 线程中的 finally 块并不一定会执行。在构建 Daemon 线程时，不能依靠 finally 块中的内容来确保执行关闭或清理资源的逻辑。