一、参考

1、java中的线程安全
2、Java总结篇系列：Java多线程（一）

二、使用场景

1、耗时的操作使用线程（异步操作），提高应用程序响应
2、并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求（多线程）。
3 、多CPU系统中，使用线程提高CPU利用率
4、改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

三、如何使用

1、生命周期

状态	含义	内容
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 易变的：他可以修饰共享变量，虽然符合【可见性】，但是依旧不是【原子性】，特别是线程中不能使用在对自身进行运算的操作上，但是他消耗内存较小，不会造成阻塞