多线程初阶（一）
目录
前言：
认识多线程
创建线程
run方法和start区别
继承Thread类
实现Runnable接口
匿名内部类实现继承Thread类
匿名内部类实现Runnable接口实例
Lambda表达式
中断线程
等待线程
线程休眠
线程状态
线程状态之间切换
代码观察线程的状态
线程安全
线程安全测试
解析
线程安全总结
小结：
前言：
多线程在实际开发中会经常使用到，它可以对于硬件资源充分的利用，提升代码的执行效率。这样会对我们开发过程中提供了很大便利。
认识多线程
上篇文章讲解了并发和并行的区别，目的就是将硬件资源得到充分利用。线程实际在操作系统内核中调度是抢占式调度，随机执行的。每个线程在cpu里执行时，都是以指令的方式去执行一个线程的，一个线程会包含多条指令。
线程在cpu里执行具体是并发还是并行，我们是不确定的，具体实现是由操作系统内核实现的。当操作系统调度一个线程，会执行多条指令。进行线程切换的时候，这个时间点是不确定的，两个线程的指令会随机组合，有无数种可能。正是由于这种抢占式调度，随机执行的方式，对于代码的执行顺序就会有很大的不确定性，这就带来了线程安全问题。
解决线程安全问题，我们就需要对于一部分指令，保证其原子性。使另一个线程阻塞等待，通过加锁实现。
创建线程
run方法和start方法区别
start是启动一个线程，当这个线程的pcb被cpu调度时，这个线程就真实存在了。线程当被调度时执行的代码就是run方法里的代码体，当run方法执行结束时，线程也就结束了，这时候线程的pcb也就释放了，但是线程的引用还在。
继承Thread类
继承Thread类，实现父类引用子类实例。
class MyThread extends Thread {@Overridepublic void run() {while (true) {System.out.println("aaaa");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class ThreadDemo1 {public static void main(String[] args) throws InterruptedException {//主线程//创建线程Thread thread = new MyThread();//启动线程thread.start();while (true) {System.out.println("bbbb");Thread.sleep(1000);}}
}
注意：这里主线程和thread引用的线程里面都有死循环代码，我们可以通过jconsole工具查看线程的一些状态。
实现Runnable接口
实现Runable接口，将实例传入Thread的构造方法。这样可以将线程具体要做的事和引用分离开，解耦合。
class MyRunable implements Runnable {@Overridepublic void run() {System.out.println("aaaa");}
}
public class ThreadDemo2 {public static void main(String[] args) {//runable描述了这个线程要干什么Runnable runnable = new MyRunable();//创建线程Thread thread = new Thread(runnable);thread.start();}
}匿名内部类实现继承Thread类
public class ThreadDemo3 {public static void main(String[] args) {//使用匿名内部类//匿名内部类为Thread的子类//创建了子类的实例，让thread引用Thread thread = new Thread() {@Overridepublic void run() {System.out.println("aaaa");}};thread.start();}
}
匿名内部类实现Runnable接口实例
public class ThreadDemo4 {public static void main(String[] args) {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("aaaa");}});thread.start();}
}Lambda表达式
由于Runnable为函数式接口，因此可以使用lanbda表达式。
//lambda表达式实现函数式接口Runable（实例其函数式接口对象）
public class ThreadDemo5 {public static void main(String[] args) {Thread thread = new Thread(() -> {System.out.println("aaa");});thread.start();}
}
中断线程
注意：终止线程只是通知说线程该终止了，但具体要不要终止是线程里说了算的。
可以手动设置标志位，通过另一个线程来改变这个标志位，进一步来决定run方法的结束，控制线程的终止。
public class ThreadDemo7 {private static boolean flag = true;public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {//设置标志位，其他线程只要改变标志位，就可以结束run方法，结束本线程while (flag) {System.out.println("aaaa");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}});thread.start();Thread.sleep(3000);flag = false;}
}1）使用自带的isInterrupted方法设置标志位。
2）interrupt方法控制标志位。
注意：isInterrupted方法初始值默认为false，可以通过interrupt设置为true。但是如果通过interrupt设置标志位的时候，这个线程处于sleep()，TIMED_WAITING状态时，就会唤醒线程。这时候sleep就会抛出一个异常，并且清空标志位，改回false。接下来要不要中断就看我们代码的结构了。
public class ThreadDemo7 {
public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {//可以获得当前线程的引用//isInterrupted()线程是否中断，默认为falsewhile (!Thread.currentThread().isInterrupted()) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();//也可等待一会再中断线程try {Thread.sleep(2000);} catch (InterruptedException ex) {ex.printStackTrace();}//跑完异常可以主动中断线程break;}System.out.println("aaaaa");}}});thread.start();Thread.sleep(3000);//当设置另一个线程标志位时（会设置为true），如果这个线程正处于休眠状态，sleep就会抛异常，并且清空标志位（改回标志位为false）//sleep清空标志位的原因：当触发sleep唤醒线程后，这个线程的状态就交给我们自己了吗，类似于代码“暂停”的做法，都会清空标志位（wait，join）thread.interrupt();//设置标志位，告诉线程该中断了}
}等待线程
由于线程的抢占式执行，随机调度。不可以确定线程的执行顺序，但是我们可以通过一个线程等待一个线程（阻塞），来控制线程的结束时间。java里使用join方法。
当线程在就绪队列里，这个线程就可以被操作系统内核调度。线程一旦阻塞就会进入阻塞队列，直到阻塞结束时，才会被调入就绪队列。
public class ThreadDemo8 {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 3; i++) {System.out.println("aaa");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}});thread.start();Thread.sleep(5000);//线程等待（阻塞）//当主线程走到join时就会阻塞，直到thread线程执行结束，才会执行主线程（thread线程肯定比main线程先结束）//可设置参数为最大阻塞时间thread.join();System.out.println("bbb");}
}
注意：当主线程执行到join就会阻塞，进入阻塞队列。直到thread线程执行结束，主线程才会进入就绪队列，就可以被操作系统内核调度。
线程休眠
线程休眠会由就绪队列换到阻塞队列。当指定的休眠时间结束，就可以由阻塞队列回到就绪队列。这样才可以被调度，所以休眠时间会大于等于我们指定的时间。java里使用sleep()方法，参数以毫秒位单位。
注意：上述代码里使用的sleep均为线程休眠。
线程状态
1）NEW：有线程对象，但没有启动线程。
2）RUNNABLE：1）线程正在cpu上执行 2）线程处于就绪队列，随时可以被调度。
3）TERMINATED：线程结束，pcb已经释放，但是线程对象还在。
线程阻塞时状态：
4）TIMED_WAITING：线程阻塞，处于sleep，wait，join等。
5）BLOCKED：等待锁产生的阻塞。
6）WAITING：等待其他线程来通知。
线程状态之间切换
注意：
线程状态之间切换主线是由NEW ---> RUNNABLE ---> TERMINATED。阻塞时的一些状态都是线程已经执行起来了，在这个基础上的一些不同方式的阻塞。线程在等待锁产生的阻塞就是BLOCKED。线程遇到sleep，join，wait等方式阻塞是TIMED_WAITING状态。当线程需要其他线程来通知时是WAITING状态。
代码观察线程的状态
public class ThreadDemo9 {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 3; i++) {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("aaa");}}});//NEW//有线程对象，但是没有启动线程System.out.println(thread.getState());thread.start();//一个线程只能start一次//RUNNABLE//可执行的，1.就绪队列 2.正在cpu上执行的for(int i = 0; i < 10; i++) {System.out.println(thread.getState());}//TIMED_WAITING//当线程处于sleep时，这个时间获取线程状态//BLOCKED//等待锁产生的最阻塞//WAIT//等待其他人来通知//(这三种状态都是在描述不同的阻塞状态)Thread.sleep(8000);//TERMINATED//线程执行结束，pcb已经释放，但对象还在System.out.println(thread.getState());}
}
线程安全
线程安全测试
class Cumsum {public int a = 0;public void add() {a++;}
}
public class ThreadDemo15 {public static void main(String[] args) {Cumsum cumsum = new Cumsum();Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 5000; i++) {cumsum.add();}}});Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 5000; i++) {cumsum.add();}}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cumsum.a);}
}
注意：这里有两个线程t1和t2，分别针对a进行累加5000次，结果很显然不是10000。为什么呢？
解析
当两个线程都启动时，它们是并发执行的。线程是抢占式调度，随机执行的。执行一次a++需要有三条指令：1.首先将内存中数据读到cpu内存中（load） 2.将寄存器中数据加一（add） 3.将寄存器中数据写回内存（save）。
由于这种抢占式调度，随机执行。这三条指令可以有无数种组合，只要第一个线程load完，没有save，这个期间第二个线程再去读内存中的数据，就会造成脏读问题（例如MySQL中的脏读），那么最终两个线程执行一次循环只会累加一次。如果在这个期间第二个线程执行了多次这三条指令，那么最终第一个线程执行一次循环，第二个线程执行多次循环也只累加一次。
只有当第一个线程save完，第二个线程再去读内存中的数据，然后save。每个线程在读数据时保证在上一个线程save之后，这样数据就是正确的，这样的作法其实就是保证了这三条指令的原子性，可以通过加锁实现指令的原子性。
//线程安全测试
class Cumsum {public int a = 0;synchronized public void add() {a++;}
}
public class ThreadDemo15 {public static void main(String[] args) {Cumsum cumsum = new Cumsum();Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 5000; i++) {cumsum.add();}}});Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 5000; i++) {cumsum.add();}}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(cumsum.a);}
}
注意：加锁之后，数据就正确了。下篇详细介绍。
线程安全总结：
1）根本原因：抢占式执行，随机调度。
2）代码结构，多个线程修改一个变量产生线程安全问题。多个线程修改多个变量，多个线程读同一个变量，一个线程修改一个变量都不会产生线程安全问题。
3）原子性，保证一些指令不可拆分（加锁）。
4）内存可见性问题（后面介绍）。
5）指令重排序（编译器优化出bug）。
小结：
多线程的学习我们需要理解线程之间的关系，理清它们执行的逻辑，分析代码。这样会对我们学习有很大帮助。