线程的概念以及状态
在学习线程之前，我们需要普及一个概念，每一个程序运行都会有一个父进程，我们的线程就是在此父进程中运行，拿Android来说，默认情况下，启动一个程序，所有的组件程序都运行在同一个进程中，并且会创建一个执行线程在该进程中，俗称"主线程",当我们在该线程中做了耗时的操作造成了程序卡顿，我们就叫“线程阻塞”了,此时就应该另起一个线程来执行耗时操作。
要了解线程中方法的使用，就得先了解线程的运行状态，线程从创建到执行完毕，一共有6个状态：
- NEW(线程创建未启动)
- RUNNABLE(正在执行中的线程)
- BLOCKED(被阻塞并且在等待监视器锁释放)
- WAITING(等待被唤醒)
- TIMED_WAITING(等待或睡眠一定时间被唤醒)
- TERMINATED（线程终止，消亡）
这些状态对应Thread源码中的State枚举，通过getState()方法可以获取该线程的运行状态
其中BLOCKED表示等待监视器锁的过程，那么什么是监视器锁呢，监视器锁是为了解决线程不安全而诞生的方法，当多个进程同时操作一个数据结构并修改时，这时数据结构是不确定的，我们称之为“线程不安全”,于是我们使用synchronized(同步锁)和lock锁等机制来解决这种线程不安全，套上此锁，当前有且只有一个线程能修改此数据结构，其他的线程则需要等待，这就保证了数据结构的一致性，而其他线程会进入等待的状态，也就是我们的BLOCKED状态。
synchronized使用示例：
class MyThread extends Thread {
@Override
public void run() {
synchronized (this) {
//这里写修改数据源的代码
}
}
}
lock使用示例：
class MyThread extends Thread {
private final ReentrantLock lock = new ReentrantLock ();
@Override
public void run() {
lock.lock();
//这里写修改数据源的代码
lock.unlock();
}
}
当然这两者的应用不仅仅是在线程中，在必要的方法调用上也可使用
线程的源码以及方法使用
Thread源码：
public class Thread implements Runnable {
...........
/* Some of these are accessed directly by the VM; do not rename them. */
private volatile long nativePeer;
volatile ThreadGroup group;
volatile boolean daemon;
volatile String name;
volatile int priority;
volatile long stackSize;
Runnable target;
private static int count = 0;
private long threadInitNumber ;
/**
* Normal thread local values.
*/
ThreadLocal.Values localValues;
/**
* Inheritable thread local values.
*/
ThreadLocal.Values inheritableValues;
/** Callbacks to run on interruption. */
private final List<Runnable> interruptActions = new ArrayList<Runnable>();
/**
* Holds the class loader for this Thread, in case there is one.
*/
private ClassLoader contextClassLoader;
/**
* Holds the handler for uncaught exceptions in this Thread,
* in case there is one.
*/
private UncaughtExceptionHandler uncaughtHandler;
/**
* Holds the default handler for uncaught exceptions, in case there is one.
*/
private static UncaughtExceptionHandler defaultUncaughtHandler;
.....
}
Thread实现了Runnable接口，并声明了一些线程常用的一些变量:
group
线程组，线程组包含其他的线程组，形成了一个树结构，除了初始的线程组外，其他的线程组都会有个父进程，其中线程能访问当前线程组的信息，但不能访问父线程组的信息daemon
是否是守护线程，啥是守护线程呢，守护线程是依赖于创建它的线程的一种线程，与普通线程的区别是当创建它的线程关闭了那它也会关闭，而普通线程不会，像我们的垃圾收集器线程就是一个守护线程threadInitNumber 当前线程的标识符，它是按照线程的创建顺序来叠加的
name 线程的名称，未指定的话就以
"Thread-" + threadInitNumber的逻辑命名priority
线程优先级，有三个状态MIN_PRIORITY,NORM_PRIORITY,MAX_PRIORITY,分别对应低，中，高stackSize 堆栈大小
target 当前的目标线程
contextClassLoader 类加载器，用于保存该线程的信息，断点续传等功能可以用到
uncaughtHandler
线程未捕获异常调用类，如果没有对其进行设置，将会默认使用defaultUncaughtHandler来处理异常，由于我们的主线程也是一个Thread,所以我们可以通过实现UncaughtExceptionHandler接口并调用Thread.setDefaultUncaughtExceptionHandler（）方法将我们自定义的异常捕获类设置给Thread,这样我们就可以捕获全局的异常
了解了一些常用变量后，我们再来看一下其中的一些常用方法:
start()方法
用于启动一个线程，只有调用此方法，系统才会新开启一个线程并分配给其必要的资源。我们看一下Thread的构造方法，发现最终都是调用了init方法，里面也只是对基本变量进行初始化，并没有分配到任何的资源：
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
Thread parent = currentThread();
if (g == null) {
g = parent.getThreadGroup();
}
g.addUnstarted();
this.group = g;
this.target = target;
this.priority = parent.getPriority();
this.daemon = parent.isDaemon();
setName(name);
init2(parent);
/* Stash the specified stack size in case the VM cares */
this.stackSize = stackSize;
tid = nextThreadID();
}
所以，新建一个线程不会消耗资源，只有当star后才会去分配必要的资源，此时线程状态由NEW变为了RUNNABLE
run()方法
此方法用于处理线程中执行的逻辑，如果继承Thread类则必须重写该方法
sleep()方法
sleep(long millis) //参数为毫秒
sleep(long millis,int nanoseconds) //第一参数为毫秒，第二个参数为纳秒
让线程休眠一段时间，相当于让线程进入阻塞状态。注意即使线程休眠了其锁机制依旧生效，其他的线程依旧不能访问其被锁的数据结构，直到其释放对象锁，此时线程状态由RUNNABLE进入TIMED_WAITING
yield()方法
让当前线程交出相应的权限，为其他线程让步，这是防止CPU过度使用的一种有效手段。效果与sleep差不多，但不能指定具体的时间，并且并不是让线程进入到阻塞状态，而是进入就绪状态.此时线程状态由RUNNABLE进入WAITING
join()方法
join()
join(long millis) //参数为毫秒
join(long millis,int nanoseconds) //第一参数为毫秒，第二个参数为纳秒
此方法是让线程优先来执行，其余的线程会暂停，直到此线程执行完毕才会继续执行。你可以将线程看成一些正常行驶的车辆(在线程队列中)，当给其中一辆车使用了join(弯道超车),那其余的车会给其让行（线程进入暂停状态），优先让它行驶(join的线程运行)，直到它到达终点(运行完成)，才会继续行驶（继续执行）
而join源码中是调用的wait()方法，而wait()方法能使线程进入阻塞状态并释放对象锁，所以join方法也是能释放对象锁的
interrupt（）方法
中断线程，我们知道，线程执行完run方法里的逻辑就会进入终止状态。调用此方法会使一个阻塞的线程抛出InterruptedException异常，从而终止线程，可以调用isInterrupted()判断是否终止了线程，但非阻塞线程如何中断呢，请看：
class MyThread extends Thread{
private volatile boolean isStop = false;
@Override
public void run() {
int i = 0;
while(!isStop){
i++;
}
}
public void setStop(boolean stop){
this.isStop = stop;
}
}
我们可以设置一个变量来控制是否执行完毕，从而结束线程，此时线程状态进入TERMINATED状态
