并发编程（一）多线程基础

#多线程使用场景
1、通过并行计算提高程序执行性能
2、需要等待网络、I/O 响应导致耗费大量的执行时间，可以采用异步线程的方式 来减少阻塞
#创建多线程
在 Java 中，有多种方式来实现多线程。继承 Thread 类、实现 Runnable 接口用ExecutorService、Callable、Future 实现带返回结果的多线程。
1、继承 Thread 类创建线程
Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。
启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法
是一个native 方法，它会启动一个新线程，并执行 run()方法。这种方式
实现多线程很简单，通过自己的类直接 extend Thread，并复写 run()
方法，就可以启动新线程并执行自己定义的 run()方法。

public class MyThread extends Thread {
 public void run() {
 System.out.println("MyThread.run()");
 }
}

2、如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，
可以实现一个 Runnable 接口

public class MyThread extends OtherClass implements Runnable {
 public void run() {
 System.out.println("MyThread.run()");
 }
} 

3、实现 Callable 接口通过 FutureTask 包装器来创建Thread 线程
有的时候，我们可能需要让一步执行的线程在执行完成以后，提供一个返回值
给到当前的主线程，主线程需要依赖这个值进行后续的逻辑处理，那么这个时
候，就需要用到带返回值的线程了

public class CallableDemo implements Callable<String> {
public static void main(String[] args) throws ExecutionException,
InterruptedException {
ExecutorService executorService=Executors.newFixedThreadPool(1);
CallableDemo callableDemo=new CallableDemo();
Future<String> future=executorService.submit(callableDemo);
System.out.println(future.get());
executorService.shutdown();
}
@Override
public String call() throws Exception {
int a=1;
int b=2;
System.out.println(a+b);
return "执行结果:"+(a+b);
}
}

#线程的状态
Java 线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，
那么我们接下来从线程的生命周期开始去了解线程。线程一共有 6 种状态
（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）
NEW：初始状态，线程被构建，但是还没有调用 start 方法
RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一
称为“运行中”
BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃
了 CPU 使用权，阻塞也分为几种情况：
Ø 等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列
Ø 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占
用了，那么 jvm 会把当前的线程放入到锁池中
Ø 其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者
发出了I/O请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、
join 线程终止、io 处理完毕则线程恢复
TIME_WAITING：超时等待状态，超时以后自动返回
TERMINATED：终止状态，表示当前线程执行完毕

#线程操作的主要方法

sleep()
使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它***并不释放对象锁***。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。
例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。
总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。
join()
join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。
yield()
该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。
wait()和notify()、notifyAll()
这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。
wait()方法使当前线程暂停执行***并释放对象锁标示***，让其他线程可以进入synchronized数据块，当前线程被放入***对象等待池***中。当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。
notifyAll()则从***对象等待池***中移走所有等待那个对象的线程并放到***锁标志等待池***中。
注意 这三个方法都是java.lang.Object的方法。
run和start()
把需要处理的代码放到run()方法中，start()方法启动线程将自动调用run()方法，这个由java的内存机制规定的。并且run()方法必需是public访问权限，返回值类型为void。
关键字synchronized
该关键字用于保护共享数据，当然前提条件是要分清哪些数据是共享数据。每个对象都有一个锁标志，当一个线程访问到该对象，被Synchronized修饰的数据将被"上锁"，阻止其他线程访问。当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。
wait()和notify(),notifyAll()是Object类的方法，sleep()和yield()是Thread类的方法。
(1)、常用的wait方法有wait()和wait(long timeout);
void wait() 在其他线程调用此对象的 notify() 方法或者 notifyAll()方法前，导致当前线程等待。
void wait(long timeout)在其他线程调用此对象的notify() 方法 或者 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。
wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其他shnchronized数据可被别的线程使用。
wait()h和notify()因为会对对象的“锁标志”进行操作，所以他们***必需在Synchronized函数或者 synchronized block 中进行调用***。如果在non-synchronized 函数或 non-synchronized block 中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
yield()没有参数
sleep 方法使当前运行中的线程睡眠一段时间，进入不可以运行状态，这段时间的长短是由程序设定的，yield方法使当前线程让出CPU占有权，但让出的时间是不可设定的。
yield()也***不会释放锁标志***。
实际上，yield()方法对应了如下操作；先检测当前是否有***相同优先级的线程***处于同可运行状态，如有，则把CPU的占有权交给此线程，否则继续运行原来的线程，所以yield()方法称为“退让”，它把运行机会让给了***同等级的其他线程***。
sleep 方法***允许较低优先级的线程***获得运行机会，但yield（）方法执行时，当前线程仍处在可运行状态，所以不可能让出较低优先级的线程此时获取CPU占有权。在一个运行系统中，如果较高优先级的线程没有调用sleep方法，也没有受到I/O阻塞，那么较低优先级线程只能等待所有较高优先级的线程运行结束，方可有机会运行。
yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。
#线程的停止
线程的启动过程大家都非常熟悉，但是如何终止一个线程，我相信绝大部分人在面试的时候被问到这个问题时，也会不知所措，不知道怎么回答。
记住，线程的终止，并不是简单的调用stop命令去。虽然api仍然可以调用，但是和其他的线程控制方法如suspend、resume一样都是过期了的不建议使用，就拿stop来说，stop方法在结束一个线程时并不会保证线程的资源正常释放，因此会导致程序可能出现一些不确定的状态。
要优雅的去中断一个线程，在线程中提供了一个interrupt方法。
当其他线程通过调用当前线程的interrupt方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己。
线程通过检查资深是否被中断来进行相应，可以通过isInterrupted()来判断是否被中断。
interrupt()方法: 作用是中断线程。
本线程中断自身是被允许的，且"中断标记"设置为true
其它线程调用本线程的interrupt()方法时，会通过checkAccess()检查权限。这有可能抛出SecurityException异常。
若线程在阻塞状态时，调用了它的interrupt()方法，那么它的“中断状态”会被清除并且会收到一个InterruptedException异常。
例如，线程通过wait()进入阻塞状态，此时通过interrupt()中断该线程；调用interrupt()会立即将线程的中断标记设为“true”，但是由于线程处于阻塞状态，所以该“中断标记”会立即被清除为“false”，同时，会产生一个InterruptedException的异常。
如果线程被阻塞在一个Selector选择器中，那么通过interrupt()中断它时；线程的中断标记会被设置为true，并且它会立即从选择操作中返回。
如果不属于前面所说的情况，那么通过interrupt()中断线程时，它的中断标记会被设置为“true”。
isInterrupted()方法
判断调用线程是否处于中断状态

public static void main(String[] args){
　　Thread thread = new Thread(()->{}); //定义一个线程，伪代码没有具体实现
　　thread.isInterrupted();//判断thread是否处于中断状态，而不是主线程是否处于中断状态
　　Thread.isInterrupted(); //判断主线程是否处于中断状态
}

interrupted()方法
判断的是当前线程是否处于中断状态。是类的静态方法，同时会清除线程的中断状态。除了通过Thread.interrupted方法对线程中断标识进行复位以外，还有一种被动复位的场景，就是对抛出InterruptedException异常的方法，在InterruptedException抛出之前，JVM会先把线程的中断标识位清除，然后才会抛出InterruptedException，这个时候如果调用isInterrupted方法，将会返回false
通过“中断标记”终止线程

@Override
public void run() {
　　while (!isInterrupted()) {
// 执行任务...
　　}
}

isInterrupted()是判断线程的中断标记是不是为true。当线程处于运行状态，并且我们需要终止它时；可以调用线程的interrupt()方法，使用线程的中断标记为true，即isInterrupted()会返回true。此时，就会退出while循环。
注意：interrupt()并不会终止处于“运行状态”的线程！它会将线程的中断标记设为true。
通过“额外添加标记”
定义一个volatile修饰的成员变量，来控制线程的终止。这实际上是应用了volatile能够实现多线程之间共享变量的可见性这一特点来实现的

private volatile boolean flag= true;
protected void stopTask() {
　　flag = false;
　　}
　　@Override
　　public void run() {
　　while (flag) {
　　// 执行任务...
　　}
}