理解Java线程
使用多线程的目的是更好的利用cpu资源，大部分多线程代码都可以用单线程来实现，但也有无法用单线程实现的，如：生产者消费者模型
下面对一些常用的概念进行区分：
多线程：指的是这个程序（一个进程）运行时产生了不止一个线程。
并行与并发：
并行：多个cpu实例或者多台机器同时执行一段处理逻辑，真正的同时。
并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。
线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。若线程不安全则意味着线程调度顺序影响最终结果。如转账操作。
同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如在转账中加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。
一、线程的状态
线程共有五种状态，其状态转换如下图所示：
- 新建态(New):新创建的线程对象。
- 就绪态(Runnable):线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。 即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。
- 运行态(Running):就绪状态的线程获取了CPU，执行程序代码。
- 死亡态(Dead):线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
- 阻塞态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
阻塞的情况分三种：
- 等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒。
- 同步阻塞：运行的线程在获取对象的同步锁时(Synchronized)，同步锁被释放进入可运行状态(Runnable),若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
- 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
注：在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。
二、控制线程的基本方法
首先就要明确monitor的概念，Java中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在synchronized 范围内，监视器发挥作用。
1、sleep()
sleep()方法属于Thread类，是一个静态方法，主要的作用是让当前线程停止执行，把cpu让给其他线程执行，但不会释放对象锁和监控的状态，到了指定时间后线程又会自动恢复运行状态
Java有两种sleep方法,一个只有一个毫秒参数,另一个有毫秒和纳秒两个参数
sleep(long millis)
sleep(long millis, int nanos)
注意：线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
2、wait()与notify()
wait()属于Object类，与sleep()的区别是当前线程会释放锁，进入等待此对象的等待锁定池。若线程A调用Obj.wait(),线程A就会停止运行，而转为等待状态。至于等待时间，看其他线程是否调用Obj.notify()，成为多个线程之间进行通讯的有手段。
注意：无论是wait()还是notify()都需要首先获得目标的对象的一个监视器。wait/notify必须存在于synchronized块中。并且，这三个关键字针对的是同一个监视器（某对象的监视器）。这意味着wait之后，其他线程可以进入同步块执行。当某代码并不持有监视器的使用权时去wait或notify，会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify，因为不同对象的监视器不同，同样会抛出此异常。
"Synchronzied"是一种同步锁。作用是实现线程间同步，对同步的代码加锁，使得每一次，只能有一线程进入同步块，从而保证线程间的安全性。它修饰的对象有以下几种：
- 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的部分,进入同步代码前要获得给定对象的锁
- 修饰一个实例方法，进入同步代码前要获得当前实例的锁
- 修饰一个静态方法，进入同步代码前要获得当前类的锁
public class Test {
final static Object object=new Object();
public static class Thread1 extends Thread{
@Override
public void run() {
synchronized (object) {
System.out.println("T1 开始");
try {
System.out.println("T1 等待");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T1 结束");
}
}
}
public static class Thread2 extends Thread{
@Override
public void run() {
synchronized (object) {
System.out.println("T2 开始");
System.out.println("释放一个线程");
object.notify();
System.out.println("T2 结束");
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread1();
Thread t2=new Thread2();
t1.start();
t2.start();
t1.join();
t2.join();
}
}
运行结果：
T1 开始
T1 等待
T2 开始
释放一个线程
T2 结束
T1 结束
如下为生产者消费者模型：
public class Test {
private final int MAX_SIZE = 100;
private LinkedList<Object> list = new LinkedList<Object>();
/**
* 生产产品
* @param producer
*/
public void produce(String producer) {
synchronized (list) {
// 如果仓库已满
while (list.size() == MAX_SIZE) {
System.out.println("仓库已满，【"+producer+"】： 暂时不能执行生产任务!");
try {
// 由于条件不满足，生产阻塞
list.wait();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
// 生产产品
list.add(new Object());
System.out.println("【"+producer+"】：生产了一个产品\t【现仓储量为】:" + list.size());
list.notifyAll();
}
}
/**
* 消費产品
* @param consumer
*/
public void consume(String consumer) {
synchronized (list) {
//如果仓库存储量不足
while (list.size()==0) {
System.out.println("仓库已空，【"+consumer+"】： 暂时不能执行消费任务!");
try {
// 由于条件不满足，消费阻塞
list.wait();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
list.remove();
System.out.println("【"+consumer+"】：消费了一个产品\t【现仓储量为】:" + list.size());
list.notifyAll();
}
}
public static void main(String[] args){
Test test = new Test();
for(int i=1;i<6;i++){
int finalI = i;
new Thread(new Runnable() {
@Override
public void run() {
test.produce(String.format("生产者%d:", finalI));
}
}).start();
}
for(int i=1;i<4;i++){
int finalI = i;
new Thread(()-> test.consume(String.format("消费者%d:", finalI))).start();
}
}
}
运行结果：
仓库已空，【消费者2:】： 暂时不能执行消费任务!
仓库已空，【消费者1:】： 暂时不能执行消费任务!
【生产者4:】：生产了一个产品 【现仓储量为】:1
【生产者1:】：生产了一个产品 【现仓储量为】:2
【消费者3:】：消费了一个产品 【现仓储量为】:1
【消费者1:】：消费了一个产品 【现仓储量为】:0
【生产者2:】：生产了一个产品 【现仓储量为】:1
【消费者2:】：消费了一个产品 【现仓储量为】:0
【生产者5:】：生产了一个产品 【现仓储量为】:1
【生产者3:】：生产了一个产品 【现仓储量为】:2
3、join()
在某些情况下，子线程需要进行大量的耗时运算，主线程可能会在子线程执行结束之前结束，但是如果主线程又需要用到子线程的结果，换句话说，就是主线程需要在子线程执行之后再结束。这就需要用到join()方法
public class Test {
public static int count;
public static class AddThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000000000; i++) {
count++;
}
}
}
public static void main(String[] args) throws InterruptedException {
AddThread addThread=new AddThread();
Thread t1=new Thread(addThread);
t1.start();
t1.join();
System.out.println(count);
}
}
4、yield()
一个线程调用yield()意味着告诉虚拟机可以把自己的位置让给其他线程(这只是暗示，并不表绝对)。但要注意，让出cpu并不代表当前线程不执行了。当前线程让出cpu后，还会进行cpu资源的争夺，但是能不能再次分配到，就不一定了。使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
5、volatile
多线程的内存模型：main memory（主存）、working memory（线程栈），在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去(volatile关键词的作用：每次针对该变量的操作都激发一次load and save)。
针对多线程使用的变量如果不是volatile或者final修饰的，很有可能产生不可预知的结果（另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值）。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的，本质上，volatile就是不去缓存，直接取值。在线程安全的情况下加volatile会牺牲性能。
二、线程创建
Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用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()");
}
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
}
}
2、实现Runnable接口创建线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，代码如下：
public class MyThread implements Runnable {
public void run() {
System.out.println("MyThread.run()");
}
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
}
}
3、实现Callable接口,通过FutureTask包装器创建线程
/**
* 实现Callable接口创建线程，相较于实现Runnable接口的方式，方法可以有返回值，并且可以抛出异常
* 执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果
*/
public class Test {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
// 执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果
FutureTask<Integer> result = new FutureTask<>(td);
new Thread(result).start();
// 接收线程运算后的结果
Integer sum;
try {
//等所有线程执行完，获取值，因此FutureTask 可用于 闭锁
sum = result.get();
System.out.println("-----------------------------");
System.out.println(sum);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ThreadDemo implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
return sum;
}
}
4、使用线程池创建返回结果的线程
使用ExecutorService、Callable、Future实现有返回结果的线程,ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，有了这种特征可以很方便的得到返回值了,可返回值的任务必须实现Callable接口。类似的，无返回值的任务必须实现Runnable接口。
执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。
注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待。再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。
public class Demo {
public static void main(String[] args) throws Exception {
System.out.println("----程序开始运行----");
Date date1 = new Date();
int taskSize = 5;
// 创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>();
for (int i = 0; i < taskSize; i++) {
Callable c = new MyCallable(i + " ");
// 执行任务并获取Future对象
Future f = pool.submit(c);
// System.out.println(">>>" + f.get().toString());
list.add(f);
}
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
for (Future f : list) {
// 从Future对象上获取任务的返回值，并输出到控制台
System.out.println(">>>" + f.get().toString());
}
Date date2 = new Date();
System.out.println("----程序结束运行----，程序运行时间【"+ (date2.getTime() - date1.getTime()) + "毫秒】");
}
}
class MyCallable implements Callable<Object> {
private String taskNum;
MyCallable(String taskNum) {
this.taskNum = taskNum;
}
public Object call() throws Exception {
System.out.println(">>>" + taskNum + "任务启动");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任务终止");
return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
}
}
运行结果：
----程序开始运行----
>>>0 任务启动
>>>2 任务启动
>>>4 任务启动
>>>1 任务启动
>>>3 任务启动
>>>2 任务终止
>>>4 任务终止
>>>0 任务终止
>>>0 任务返回运行结果,当前任务时间【1000毫秒】
>>>1 任务终止
>>>3 任务终止
>>>1 任务返回运行结果,当前任务时间【1000毫秒】
>>>2 任务返回运行结果,当前任务时间【1000毫秒】
>>>3 任务返回运行结果,当前任务时间【1000毫秒】
>>>4 任务返回运行结果,当前任务时间【1000毫秒】
----程序结束运行----，程序运行时间【1074毫秒】
程序说明：
上述代码中Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。
本文参考了：
https://www.cnblogs.com/wxd0108/p/5479442.html
https://www.cnblogs.com/Ming8006/p/7243858.html
https://www.cnblogs.com/felixzh/p/6036074.html
https://www.cnblogs.com/ccfdod/p/6396012.html
http://www.cnblogs.com/jijijiefang/articles/7222955.html
