1 多线程
1.1 程序和进程
还没运行的程序就是一连串代码（具有描述性的文字）
程序一旦运行便会产生进程，进程一直向前运行，直到进程结束。
1.2 操作系统的发展
单任务操作系统:在一个时间段里只单独运行一个程序，若要运行下一个程序需要把上一个程序运行完。不能同时运行多个程序，这就导致了CPU利用率低下的问题。
↓
进程
程序的一次运行产生进程(内存空间、资源、程序的执行堆栈)
进程作为操作系统分配资源的基本单位。
↓
多任务操作系统
一台电脑就一个CPU，多个任务轮流使用CPU，从宏观上看，一段时间有多个任务正在运行。
从微观上看，一个时间点只有一个任务在运行。
CPU时间片
多个进程通过CPU时间片轮转实现多任务(进程)。把这种现象叫做并发操作
并行:
一个时间段，多个任务同时进行，多个CPU运行各自的进行。
↓
线程的引入
解决实时性问题
1.3 进程和线程区别
综合性案例
1.4 多线程实现
Thread 类位于java.lang中，表示进程中的执行线程。实现多线程有两种方式
1.4.1 [1] 继承Thread
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("我是多线程MyThread");
for (int i = 0; i < 5; i++) {
System.out.println("MyThread:" + i);
}
}
}
public class Test01 {
public static void main(String[] args) {
// main开始运行产生一个进程，该进程默认有个主(main)线程
// 创建线程
MyThread t1 = new MyThread();
// 启动线程
t1.start();
for (int i = 0; i < 5; i++) {
System.out.println("main Thread:" + i);
}
}
}
main线程和t1线程抢占CPU 执行。多线程在提高CPU利用率的同时，也会增加程序的复杂度。
1.4.2 [2]实现Runnable接口
public class MyRun implements Runnable {
@Override
public void run() {
System.out.println("我是MyRun");
for (int i = 0; i < 5; i++) {
System.out.println("my run:" + i);
}
}
}
public class Test02 {
public static void main(String[] args) {
MyRun run = new MyRun();
Thread t1 = new Thread(run);
t1.start();
// main开始运行产生一个进程，该进程默认有个主(main)线程
for (int i = 0; i < 5; i++) {
System.out.println("main Thread:" + i);
}
}
}
火车票案例:
继承Thread和实现Runnable接口实现多线程的优缺点
[1] 继承Thread的线程类不能再继承其他类（类是单继承的），实现Runnable接口的类还可以继承其他类。
[2] 实现Runnable接口的线程类，可以让多个线程共享线程实现类的资源。
总结:
多线程虽然能提高cpu的利用率，但程序的复杂度也随之增加。
一旦线程开始执行，很难通过其他方式控制线程的轨迹。
多个线程抢占CPU导致线程的运行轨迹不确定。
分析运行轨迹(A)
窗口A卖出一张票，还剩4张票
窗口B卖出一张票，还剩3张票
窗口B卖出一张票，还剩0张票
窗口C卖出一张票，还剩1张票
窗口A卖出一张票，还剩2张票
窗口A抢占到CPU，执行run，count=5
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
窗口B抢占到CPU，count=4，执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
窗口A到抢占CPU，count=3，执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--; =>[kc1] count=2
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
窗口C到抢占CPU，count=2，执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--; =>[kc2] count=1
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
窗口B抢占CPU，count=1，从上次挂起的位置开始执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--;
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); => [kc3] count=0
}
}
}
窗口C抢占到CPU，count=0，从上次挂起位置开始执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--; =>[kc4] count=1
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
窗口A抢占到CPU，count=0，从上次挂起的位置开始执行run
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
if (count > 0) {
count--; =>[kc5] count=2
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
结论
[1]多线程抢占CPU执行，可能在任意位置被切换出去(时间片长度不定)。
[2]多线程抢占到CPU后，在上次挂起的位置继续执行(先恢复上次的执行堆栈)。
[3]多线程都可以独立运行，相互不干扰，多个线程都能访问到共享资源，容易导致数据错乱！！！
1.5 线程的生命周期
新生状态
用new关键字建立一个线程后，该线程对象就处于新生状态。
处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。
就绪状态
处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。
当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。
运行状态
在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。
如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。
阻塞状态
处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。
在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。
死亡状态
死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行
的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个
线程【不推荐使用】；三是线程抛出未捕获的异常。
1.6 线程常用方法
1.6.1 [1]线程优先级
public static void main(String[] args) {
System.out.println(Thread.MIN_PRIORITY);
System.out.println(Thread.MAX_PRIORITY);
System.out.println(Thread.NORM_PRIORITY);
//主线程的优先级（默认优先级）
System.out.println(Thread.currentThread().getPriority());
Thread01 t1 = new Thread01();
// 设置线程的优先级
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
Thread01 t2 = new Thread01();
// 设置线程的优先级
t2.setPriority(Thread.MIN_PRIORITY);
t2.start();
}
线程优先级高，被cpu调度的可能性越大，但不表示一定会被优先调度。
1.6.2 [2]isAlive
判断线程是否处于活动状态。
Thread01 t1 = new Thread01();
System.out.println(t1.isAlive());
// 设置线程的优先级
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
System.out.println(t1.isAlive());
线程调用start之后就处于活动状态。
1.6.3 [3]join
线程调用join方法后会被强制执行，其它线程将处于阻塞状态，待该线程执行完毕，其它线程方可执行
。join称为线程的强制执行，运行时有可能被外界中断，因此会产生InterruptedException （中断异常）。
public class Test02 {
public static void main(String[] args){
Thread02 t = new Thread02("线程A");
t.start();
for (int i = 0; i < 5; i++) {
if(i == 2) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
1.6.4 [4]sleep()
调用该方法的线程按指定的睡眠时间（ms）立即进入睡眠状态。被休眠的线程会进入阻塞状态。
public static void main(String[] args) {
Thread03 t = new Thread03("线程A");
t.start();
Thread mainThread = Thread.currentThread();
System.out.println(mainThread.getName()+"即将进入休眠");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 中断线程
t.interrupt();
System.out.println(mainThread.getName()+"休眠完成");
}
1.6.5 [5] yield()
public static void main(String[] args) {
Thread mainThread = Thread.currentThread();
Thread04 t = new Thread04("线程A");
t.start();
for (int i = 0; i < 5; i++) {
if (i == 2) {
// yield 使当前礼让一次
Thread.yield();
}
System.out.println(mainThread.getName() + "->" + i);
}
}
A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.
当前线程给CPU调度器一个暗示，暗示其想礼让一次拥有的CPU，CPU调度者也可以忽略这次暗示。此时当前线程进入就绪状态。（申请礼让的线程会进入就绪状态，CPU调度的时候可能会选中该线程）
[6] 线程的终止。
就目前而言，不推荐使用stop直接终止线程。我们可以使用interrupt()方法来中断正在执行的线程，而在线程内部一定要写捕获中断的异常。通过异常处理机制正常结束线程。
1.7 线程的安全问题(线程同步)
线程在执行过程中，线程运行的时间片不确定、被调用的线程也不确定（即线程被执行的轨迹不确定）。对共享资源的访问很容易造成数据的错乱。我们称这个错乱称为线程安全问题。
1.7.1 同步概念
原子性操作: 执行一个操作要么一次性做完，要么根本不开始，不存在中间状态。
案例:ATM取现操作
同步就是让操作保持原子性（即要被执行，要不就执行到底）！java提供两种方式实现同步。
1.7.2 同步代码块
把所有的同步操作放到同步代码块中，
synchronized (mutex) {
// .. .
}
mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。一般用共享资源作为同步锁，也称同步监视器。
public class MyRun implements Runnable {
// 共享资源
private int count = 5;
@Override
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
// 同步代码块
// mutex 互斥锁
synchronized (this) {
if (count > 0) {
try {
Thread.sleep(3000);
count--;
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
}
}
总结
synchronized(obj){}中的obj称为同步监视器
同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器。
为何推荐使用共享资源作为监视器？
每个线程都可以对共享资源的内容申请，但是一个线程（下文称该线程）对共享资源上锁之后其他线程将无法对其申请资源。由于资源缺失而进入阻塞状态。而该线程将因为其他线程被阻塞而执行至线程结束，即原子性操作。从而达到了同步的效果。
1.7.3 同步方法
如果同步代码(原子性)很多，可以考虑使用同步方法。
把普通方法用 synchronized 修饰，同步方法的同步监视器是this。
public class MyRun implements Runnable {
// 共享资源
private int count = 5;
@Override
public void run() {
// 模拟一个窗口5个人
for (int i = 0; i < 5; i++) {
this.saleTicket();
}
}
// 同步方法默认对this加锁
private synchronized void saleTicket() {
if (count > 0) {
try {
Thread.sleep(3000);
count--;
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
}
}
}
