## 线程的交互
线程的特点是共享进程的资源，内存的存储空间，但是CPU在某一时刻只能供一个线程占用，由于存在这样的情况，所以，线程的运行有一些比较难控制的地方，当多个线程都想占用CPU的时候就需要来一场决斗决定那一个线程占用CPU了，否则线程世界就混乱了，当然，处理的方式有好多种，和我们人类世界一样，弱肉强食，分成三六九等依次占用，或者先到先得
~~~java
/**
* 宇宙的能量系统
* 遵循能量守恒定律：
* 能量不会凭空创生或消失，只会从一处转移到另一处
*/
public class EnergySystem {
//能量盒子，能量存贮的地方
private final double[] energyBoxes;
//创建锁对象
private final Object lockObj = new Object();
/**
*
* @param n 能量盒子的数量
* @param initialEnergy 每个能量盒子初始含有的能量值
*/
public EnergySystem(int n, double initialEnergy){
energyBoxes = new double[n];
for (int i = 0; i < energyBoxes.length; i++)
energyBoxes[i] = initialEnergy;
}
/**
* 能量的转移，从一个盒子到另一个盒子
* @param from 能量源
* @param to 能量终点
* @param amount 能量值
*/
public void transfer(int from, int to, double amount){
//synchronized关键字实现互斥行为
synchronized(lockObj){
// if (energyBoxes[from] < amount)
// return;
//while循环，保证条件不满足时任务都会被条件阻挡
//而不是继续竞争CPU资源
while (energyBoxes[from] < amount){
try {
//条件不满足, 将当前线程放入Wait Set
lockObj.wait();//使线程进入等待的阶段
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(Thread.currentThread().getName());
energyBoxes[from] -= amount;
System.out.printf("从%d转移%10.2f单位能量到%d", from, amount, to);
energyBoxes[to] += amount;
System.out.printf(" 能量总和：%10.2f%n", getTotalEnergies());
//唤醒所有在lockObj对象上等待的线程
lockObj.notifyAll();
}
}
/**
* 获取能量世界的能量总和
*/
public double getTotalEnergies(){
double sum = 0;
for (double amount : energyBoxes)
sum += amount;
return sum;
}
/**
* 返回能量盒子的长度
*/
public int getBoxAmount(){
return energyBoxes.length;
}
}
~~~
~~~java
public class EnergySystemTest {
//将要构建的能量世界中能量盒子数量
public static final int BOX_AMOUNT = 100;
//每个盒子初始能量
public static final double INITIAL_ENERGY = 1000;
public static void main(String[] args){
EnergySystem eng = new EnergySystem(BOX_AMOUNT, INITIAL_ENERGY);
for (int i = 0; i < BOX_AMOUNT; i++){
EnergyTransferTask task = new EnergyTransferTask(eng, i, INITIAL_ENERGY);
Thread t = new Thread(task,"TransferThread_"+i);
t.start();
}
}
}
~~~
~~~java
public class EnergyTransferTask implements Runnable{
//共享的能量世界
private EnergySystem energySystem;
//能量转移的源能量盒子下标
private int fromBox;
//单次能量转移最大单元
private double maxAmount;
//最大休眠时间（毫秒）
private int DELAY = 10;
public EnergyTransferTask(EnergySystem energySystem, int from, double max){
this.energySystem = energySystem;
this.fromBox = from;
this.maxAmount = max;
}
public void run() {
try{
while (true){
int toBox = (int) (energySystem.getBoxAmount()* Math.random());
double amount = maxAmount * Math.random();
energySystem.transfer(fromBox, toBox, amount);
Thread.sleep((int) (DELAY * Math.random()));
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
~~~
### 争用条件指：
当多个线程同时共享访问同一数据（内存区域）时，每个线程都尝试操作该数据，从而导致数据被破坏的现象，这是应该避免的事情，所以，就产生了线程世界中的优先级的各种算法，比如：先到先得、优先级、轮询等等。
### 互斥的实现：
synchronized（lockObj）;java的语法保证的同一时间，只有一个线程获得lockObj
### 同步：
wait(),notify(),notifyall(),都是属于object类，并不是thread类
### wait set
类似于线程的休息室，访问共享数据的代码称为critical section。一个线程获取锁，然后进入临界区 ，发现某些条件不满足，然后调用锁对象上的wait方法，然后线程释放掉锁资源，进入锁对象上的wait set。其他线程可以获取所资源，然后执行，完了以后调用notify，通知锁对象上的等待线程。
Ps：若调用notify();则随机拿出（这随机拿出是内部的算法，无需了解）一条在等待的资源进行准备进入Critical Section；若调用notifyAll();则全部取出进行准备进入Critical Section。
1、Java Memory Mode:JMM描述了java线程如何通过内存进行交互，了解happens-before,synchronized,voliatile & final
2、Locks % Condition：锁机制和等待条件的高层实现 java.util,concurrent.locks
3、线程安全性：原子性与可见性，死锁等
4、多线程常用的交互模型
· Producer-Consumer模型
· Read-Write Lock模型
· Future模型
· Worker Thread模型
5、Java5中并发编程工具：java.util.concurrent 线程池ExcutorService Callable&Future BlockingQueue
6、推荐书本：CoreJava & JavaConcurrency In Practice
