一、参考
二、使用场景
1、耗时的操作使用线程（异步操作），提高应用程序响应
2、并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求（多线程）。
3 、多CPU系统中，使用线程提高CPU利用率
4、改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
三、如何使用
1、生命周期
thread_status.jpg
| 状态 | 含义 | 内容 |
|---|---|---|
| New | 新建状态 | 当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); |
| Runnable | 就绪状态 | 当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； |
| Running | 运行状态 | 当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中； |
| Blocked | 阻塞状态 | 处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种： |
| - | 等待阻塞 | 运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态； |
| - | 同步阻塞 | 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态； |
| - | 其他阻塞 | 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。 |
| Dead | 死亡状态 | 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。 |
2、创建启动
已知Thread是实现Runable接口的，最终Runable中的run()方法才是最终需要执行的内容
2.1、新建Runable类实例，创建Thread时候入参Runable，这时候会执行Thread的init方法，会把此Runable变为Thread的一个Runable的类变量target
部分源码
/* What will be run. */
private Runnable target;
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
@Override
public void run() {
if (target != null) {
target.run();
}
}
启动，结果是：runable running
/**
* print: runable running
* */
private Runnable myRun = new Runnable() {
@Override
public void run() {
ComUtil.print("runable running");
}
};
Thread a = new Thread(myRun);
a.start();
2.2、新建自定义Thread类，然后复写run方法，那么如果此时创建的时候还入参一个runnable对象会怎么样呢？
启动，结果：thread running ， 虽然入参了变成Thread里的target了，可是此thread复写了Runable接口的run方法，所有不走父类的run了，直接走子类。如果还想走父类的run，那么在run方法里面写：super.run();
/**
* print: thread running
* */
private Thread myThread = new Thread(myRun){
@Override
public void run() {
ComUtil.print("thread running");
}
};
2.3、使用Callable和Future接口创建线程。。。
3、常用方法
| 方法 | 含义 |
|---|---|
| sleep() | 暂停阻塞等待一段时间，时间过了就继续。 |
| wait() | 也是阻塞和等待，但是需要notify来唤醒。 |
| join() | 在一个线程中调用other.join(),将等待other执行完后才继续本线程 |
| notify()、notifyAll() | 唤醒线程 |
| yield() | 当前线程可转让cpu控制权，让别的就绪状态线程运行（切换），也会等待阻塞一段时间，但是时间不是由客户控制了 |
| interrupte() | 打断线程，代替过时方法stop() |
| setPriority() | MIN_PRIORITY 最小优先级=1 ， NORM_PRIORITY 默认优先级=5 ，MAX_PRIORITY 最大优先级=10 |
public void testSleepAndWait(){
Thread t1 = new Thread(run1);
t1.start();
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t2 = new Thread(run2);
t2.start();
}
private Runnable run1 = new Runnable() {
@Override
public void run() {
synchronized (ThreadTest.class){
ComUtil.print("run_1 ready and waiting...");
try {
//等待阻塞，等唤醒，如果不换型，就一直挂着
//然后释放锁，让给其他线程使用
ThreadTest.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
ComUtil.print("run_1 running...");
ComUtil.print("run_1 dead");
}
}
};
private Runnable run2 = new Runnable() {
@Override
public void run() {
synchronized (ThreadTest.class){
ComUtil.print("run_2 ready");
ComUtil.print("run_2 running and sleep...");
//唤醒阻塞的线程，重新进入监视锁状态，并准备抢锁
ThreadTest.class.notify();
//不释放锁，仅仅睡一会，一会继续
//直到完成，锁才让给其他等待运行的线程
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ComUtil.print("run_2 dead");
}
}
};
1、加入wait的唤醒,notify，运行结果如下
run_1 ready and waiting...
run_2 ready
run_2 running and sleep...
run_2 dead
run_1 running...
run_1 dead
2、注释掉notify
run_1 ready and waiting...
run_2 ready
run_2 running and sleep...
run_2 dead
四、线程安全
1、一般说线程安全需要符合【原子性】和【可见性】和【顺序的】，那么使用多线程时候如果稍有不注意，很多操作就是非原子性的，会导致一些问题。
EG：最常见的一个案例：同一个时间，银行三个柜台同时向一个账户存钱，因为线程间是不能互相传递数据的，这就导致操作同一个共享对象的内存在某个线程改变时候，在其他线程不会随时更新，就会导致一个问题。
2、保证线程安全的常用方式
| 方式 | 含义 | 原则 |
|---|---|---|
| lock | 锁 | 重量型（消耗内存较多），原子性，可见的，顺序：公平锁 、非顺序：非公平锁 |
| synchronized | 同步的，互斥的 | 重量型（消耗内存较多），原子性，可见的 |
| volitail | 易变的 | 轻量型（消耗内存较少），非原子性，可见的，主要针对共享变量，改变时候其他线程中也随时会改变，但依旧是非原子性的，不是任何场景适合使用 |
共通部分代码
//不同地方，几乎同一时间向同一个账户保存10，20，70，总共100元
public void save(){
new Thread(){
@Override
public void run() {
saveMoney(1,10,this.getName());
}
}.start();
new Thread(){
@Override
public void run() {
saveMoney(2,20,this.getName());
}
}.start();
new Thread(){
@Override
public void run() {
saveMoney(3,70,this.getName());
}
}.start();
try {
Thread.sleep(1000);
ComUtil.print("最后账户="+mAcount);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
1、Lock 锁：那个线程先抢到锁，其他线程调用到此方法时候休眠，直到这个线程释放锁，其他线程能继续运行此方法
ReentrantLock 有机会再好好讲一下
private Lock lock = new ReentrantLock();//注意这个地方
private void saveMoney(int time,int money,String tName){
lock.lock();
try {
Thread.sleep(100);
mAcount += money;
ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
结果：原子的，可见的，顺序：公平锁 、非顺序：非公平锁
线程：Thread-1，第【1】次存钱，账户=10
线程：Thread-2，第【2】次存钱，账户=30
线程：Thread-3，第【3】次存钱，账户=100
最后账户=100
2、synchronized 同步的，互斥的： 1、同步代码块，非静态同步，同步当前实例 2、同步代码块，静态同步，同步类.class 3、还可以修饰方法
private void saveMoney(int time,int money,String tName){
synchronized (this){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
mAcount += money;
ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);
}
}
private synchronized void saveMoney(int time,int money,String tName){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
mAcount += money;
ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);
}
结果：原子的，可见的，非顺序的
线程：Thread-1，第【1】次存钱，账户=10
线程：Thread-3，第【3】次存钱，账户=80
线程：Thread-2，第【2】次存钱，账户=100
最后账户=100
3、volatile 易变的：他可以修饰共享变量，虽然符合【可见性】，但是依旧不是【原子性】，特别是线程中不能使用在对自身进行运算的操作上，但是他消耗内存较小，不会造成阻塞
