1 线程状态
线程的状态，参考Thread的内部枚举类型State是如何定义的：
1.1 New
被new出来的Thread对象，还没有开始运行时处于New状态。
1.2 Runnable
调用线程的start()方法之后的状态。可能正在运行，也可能没有。现代桌面操作系统都使用抢占式策略分配时间片，也就是优先级高的线程可以直接打断正在运行的优先级低的线程，抢占时间片。
1.3 blocked或者waiting
此时线程不运行任何代码，消耗很少的资源。
Blocked
当一个线程试图获取一个另一线程已经持有的 内部对象锁（intrinsic object lock），而不是concurrent library中的锁，就会处于Blocked的状态。即试图进入synchronized代码块失败时。Waiting
当一个线程等待另一线程通知调度器某个条件时。例如：Object.wait()、Thread.join()以及等待concurrent library中的Lock或者Condition。（实践中与blocked的区别不是很明显）time-waiting
通过调用带有时间参数的方法使得线程进入waiting状态。直到时间耗尽或者受到合适的消息通知时才会改变该状态。包括Thread.sleep、Object.wait、Thread.join、 Lock.tryLock、 Condition.await(都需要带上时间参数)。
当一个线程被激活（等待时间耗尽或者获取到锁），调度器会检查它的优先级是否高于当前运行线程的优先级，如果是的话，则抢占当前线程，选择一个新的线程运行。
1.4 Terminated
两个原因导致线程Terminated：
- run方法正常退出导致线程正常结束
- run方法出现未捕获异常
2 线程优先级
java每一个线程都优先级，优先级默认与创建该线程的线程优先级一致，默认为5。android官方文档推荐，每个线程都需要手动去设置优先级，这样有利于线程调度。
3 线程同步
3.1 为什么需要线程同步？
多个线程对同一共享数据进行读写，由于线程执行顺序的不同，有可能产生错误的结果。这种情况称之为“竞态条件”。
最常见的竞态条件就是“先检查后执行”操作(例如懒汉式单例模式)以及“读取--修改--写入”（例如a++）操作，即通过一个可能失效的观察结果来决定下一步的动作。在读取后，写入前， 中间任意时刻该变量都可能被其它线程修改。
基于以上竞态条件，需要对线程进行同步。即有多个线程对共享数据进行读写时，一个特定时刻只能有一个线程去操作该共享数据，别的线程只能等其操作完成之后再去操作。
3.2 如何进行线程同步
要做到一个特定时刻只能有一个线程去操作共享数据，很容易想到对共享数据进行加锁。java里面的加锁，是对持有该共享数据的对象进行加锁。每一个java对象，在内存中的布局分为3块区域：对象头、实例数据和对齐填充。在HotSpot虚拟机的实现中，对象头包含对象运行时的数据以及类型指针（标记该对象是哪个类的实例）。而运行时数据就包括hashcode、GC分代年龄、锁状态标记等信息。
java api有为我们提供了锁，可以直接拿来用，例如使用ReentrantLock保护代码块的基本结构为：
ReentrantLock mLock = new ReentrantLock();
mLock.lock();
try {
//critical section临界区
}
finally {
mLock.unlock();
}
在进入了临界区之前加锁，操作完成后释放锁。
这个结构可以确保任何时刻只有一个线程可以进入临界区。一旦有一个线程锁住了该对象，则其他线程再调用lock方法时，会被阻塞，直到该锁被释放。
释放锁的操作必须放在finally语句块中，要不然一定临界区代码抛异常，则该锁永远不会被释放，其他线程会永远阻塞。
注意，锁是可以重入的。即同一线程可以重复持有已经持有的锁。锁保持一个持有计数来跟踪对lock方法的嵌套调用。线程每一个调用lock之后，都要使用unlock来释放锁。基于以上机制，可以再同步方法中，调用另一个使用相同锁的方法。
3.3 条件对象
当线程获取锁之后进入临界区，发现条件不合适继续往下执行（显然条件判断应该处于临界区内，要不然又会产生竞态条件），需要有一个机制让其进入等待状态并释放锁，等条件适合其执行之后，再将其唤醒。显然，该线程进入等待状态时需要释放锁，这样其它线程才能进入临界区，改变条件。
举个栗子，银行转账时，需要转账金额不大于余额才能转账。
Condition mCondition = mLock.newCondition();
public void transform(int from,int to,int amount) throws InterruptedException{
mLock.lock();
try {
while(amount>account[from]){
//wait
mCondition.await();
}
//转账
...
mCondition.signalAll();
}finally {
mLock.unlock();
}
}
这里需要使用while循环，每次唤醒并分配到cpu时间片时，都需要检查条件是否满足。
另外，signalAll()只是解除该条件下等待线程的阻塞状态，以便当前线程退出之后，这些线程有资格被线程调度器执行。
注意：1 每一个锁可以有多个条件对象，用来细粒度的控制线程
3.4 synchronized关键字
前面介绍了Lock和Condition对象，理解自己加锁的方式之后，我们再来看java虚拟机自动给我们加锁的方式：synchronized。使用synchronized关键字，系统将自动加锁。每一个对象都有一个内部锁（Intrinsic Lock）。如果一个方法使用synchronized来申明，则系统自动使用该对象的内部锁。如果是static方法则使用该类的Class对象的内部锁。
注意：内部对象锁只有一个相关条件。wait 方法添加一个线程到等待集中， notifyAll、notify方法解除等待线程的阻塞状态。
3.5 Lock和synchronized的对比
3.5.1 性能
java6使用了逐步升级的方式来管理内置锁，性能大大提高，两者性能差不多。
3.5.2 功能
synchronized为系统自动加锁和释放锁，使用更加简洁。
Lock则更加灵活。
synchronized有以下局限：
- 1 不能中断一个正在试图获取锁的线程。
- 2 不能为获取锁操作设定超时时间
在开始请求锁之后，这个操作无法取消。 - 3 每个锁只有单一的条件，可能是不够的。
- 4 非公平锁
- 5 只能对代码块加锁
即释放锁的操作与获取锁的操作处于同一个代码块。
Lock/Condition 结构提供的独有特性：
- 1 可以尝试获取锁，即轮询锁，并为获取锁操作设定超时时间
可以根据尝试获取锁的结果进行下一步操作。
ReentrantLock mLock = new ReentrantLock();
public void testTryLock(){
boolean locked = false;
// locked = mLock.tryLock();
locked = mLock.tryLock(5, TimeUnit.SECONDS);
try {
if(locked){
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked){
mLock.unlock();
}
}
}
在共享通信线路上发一条消息，如果不能在指定时间内完成，代码就会失败。
public boolean trySendOnSharedLine(String message,long timeout,TimeUnit unit) throws InterruptedException {
if(!mLock.tryLock(timeout, unit)){
return false;
}
try{
return sendOnShareLine(message);
}finally {
mLock.unlock();
}
- 2 可以中断试图获取锁的线程，即对interrupt进行响应
ReentrantLock mLock = new ReentrantLock();
public void testTryLock() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
mLock.lockInterruptibly();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
mLock.unlock();
}
}
});
//可以被打断
thread.interrupt();
}
- 3 可以多条件控制
- 4 可以对非块结构进行加锁，例如散列容器的分段锁。
- 5 可以构造为公平锁。
公平锁即安排等待锁的顺序获取锁，相对来说性能差一些，只有在确定需要这个功能时才初始化为公平锁。
结论：只有在需要使用Lock、 Condition的特有功能时，才使用Lock。
