一、Android中的Thread
定义：线程，可以看作是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
1.1 Thread主要函数
| 函数名 | 作用 |
|---|---|
| run() | 线程运行时所执行的代码 |
| start() | 启动线程 |
| sleep()/sleep(long millis) | 线程休眠，进入阻塞状态，sleep方法不会释放锁（其它线程不会进入synchronized方法体或方法块，不释放锁需要try/catch） |
| yield() | 线程交出CPU，但是不会阻塞而是重置为就绪状态，不会释放锁 |
| join()/join(long millis)/join(long millis,int nanoseconds) | 线程插队，当该子线程执行完毕后接着执行其它 |
| wait() | 进入阻塞状态，释放锁（其它线程可以进入synchronized方法体或方法块，释放锁不需要try/catch） |
| interrupt() | 中断线程，注意只能中断阻塞状态的线程 |
| getId() | 获取当前线程的id |
| getName()/setName() | 获取和设置线程的name |
| getPriority()/setPriority() | 获取和设置线程的优先级，范围1-10，默认是5 |
| setDaemon()/isDaemo() | 设置和获取是否守护线程 |
| currentThread() | 静态函数获取当前线程 |
1.2 Thread的几种状态
- 新建状态（new）：实例化之后进入该状态；
- 就绪状态（Runnable）：线程调用start()之后就绪状态等待cpu执行，注意这时只是表示可以运行并不代表已经运行；
- 运行状态（Running）：线程获得cpu的执行，开始执行run()方法的代码；
- 阻塞状态（Blocked）：线程由于各种原因进入阻塞状态：join()、sleep()、wait()、等待触发条件、等待由别的线程占用的锁；
- 死亡状态（Dead）：线程运行完毕或异常退出，可使用isAlive()获取状态。
二、Android中Thread的使用
这里写出三种使用方式：
1. 继承Thread，重写run()方法。
使用时直接new并且start()。（不知道什么时候run()方法变成重写了，以前可是没有 @Override）
public class MyThread extends Thread{
@Override
public void run() {
super.run();
// do something
}
}
// Thread使用
public void goThread(){
new MyThread().start();
}
2. 实现Runnable，重写run()方法来执行任务。
public class MyRunnable implements Runnable{
@Override
public void run() {
// do something
}
}
new Thread(new MyRunnable()).start();
另一种启动方式
new Thread(new Runnable() {
@Override
public void run() {
}
}).start();
3. 通过Handler启动线程。
首先定义好Handler和Runnable ：
private int count = 0;
private Handler mHandler = new Handler();
private Runnable runnable = new Runnable() {
@Override
public void run() {
Log.i("download",Thread.currentThread().getName()+":"+count);
count ++;
mHandler.postDelayed(runnable,1000); // 执行后延迟1000毫秒再次执行，count已++
}
};
然后使用mHandler的post()方法执行线程。当上方的Runnable执行后里面定义了mHandler.postDelayed(runnable,1000);开启延迟1000毫秒后再次执行。
findViewById(R.id.btn_download).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mHandler.post(runnable); // handler运行runnable
}
});
三、Thread使用其它问题
3.1 如何终止线程
1. 使用boolean变量作为标记
如下，如果变量stop为true则跳出run()方法。关键字volatile表示这个变量随时都有可能发生变化，主要是表示同步，也就是同一时刻只能由一个线程来修改该变量的值。
public class ThreadStopTest extends Thread {
public volatile boolean stop = false;
@Override
public void run() {
super.run();
while (!stop){
// thread runing
}
}
}
2. 使用interrupt()
该方法可以用来中断进程，然后就可以终止线程，使用该方法分两种情况，线程正常运行状态和阻塞状态。
（1） 线程正常运行状态
要注意的是interrupt()方法只是中断线程而不是结束线程，在线程正常运行状态下使用该方法是不能结束线程的，正确的做法是判断线程是否被中断来决定是否执行代码。这种方法类似于自定义标记。看一下示例：
...
// 定义开始和结束线程的方法，与按钮绑定
public void goThread(){
if(null == myThread){
myThread = new MyThread();
}
myThread.start();
}
private void stopThread() {
if(null != myThread && myThread.isAlive()){
myThread.interrupt();
myThread = null;
}
}
public class MyThread extends Thread{
@Override
public void run() {
super.run();
int i = 0;
// 判断状态，如果被打断则跳出并将线程置空
while (!isInterrupted()){
i++;
Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i);
}
}
}
（2） 线程阻塞状态
先看下面的例子，重新写了一个SleepThread，开启和停止的代码省略。这个线程里每间隔1s循环增加i的值并打印。
public class SleepThread extends Thread{
@Override
public void run() {
super.run();
int i = 0;
while(true){
try {
i++;
Thread.sleep(1000);
Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i);
} catch (InterruptedException e) {
e.printStackTrace();
Log.i("thread",Thread.currentThread().getName()+"异常抛出，停止线程");
break;
}
}
}
}
当我开始和终止该线程后Log如下：
10-14 19:46:57.562 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:1
10-14 19:46:58.562 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:2
...
10-14 19:47:01.564 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142:Running()_Count:5
10-14 19:47:01.931 32024-32227/com.sky.androidthreadapp I/thread: Thread-16142异常抛出，停止线程
可以看到调用interrupt()方法后抛出InterruptedException异常，同时break跳出循环达到停止跑代码的作用。原理是当线程进入阻塞状态时，调用interrupt()方法会抛出异常，利用这个异常来跳出循环。
（3） 两种状态一起处理
此外，把两种状态的处理结合在一起是比较好的，这样既可以及时判断线程状态又可以捕获异常来跳出循环。
public class SleepThread extends Thread{
@Override
public void run() {
super.run();
int i = 0;
while(!isInterrupted()){ // 判断线程是否被打断
try {
i++;
Thread.sleep(1000);
Log.i("thread",Thread.currentThread().getName()+":Running()_Count:"+i);
} catch (InterruptedException e) {
e.printStackTrace();
Log.i("thread",Thread.currentThread().getName()+"异常抛出，停止线程");
break;// 抛出异常跳出循环
}
}
}
}
3. 使用stop()方法终止线程
恕我直言，这个方法就忽略吧，这个相当于强制关机，万一数据丢失得不偿失。
3.2 线程安全与线程同步
1. 什么是线程安全问题
简单地说，线程安全问题是指多个线程访问同一代码或数据，造成结果和数据的错乱或与期望的结果不同所产生的问题。
2. 如何解决线程安全问题
基本上所有的并发模式在解决线程安全问题的问题上，都采用“序列化访问临界资源”的方案，即在同一时刻只能有一个线程访问临界资源（多个线程可能同时访问的数据或资源），也称同步互斥访问。
（1） synchronized 关键字，保证同时刻只有一个线程进入该方法或者代码块，使用方式（Tips：java中有很多方式来实现线程同步，我们常用的synchronized是效率最低的...但是它方便啊）：
- 线程
run()方法中要执行的代码方法添加synchronized关键字，注意要添加在方法的返回值前。
int count = 100;
private synchronized void count() {
if (count > 0) {
Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
} else {
isRunning = false;
}
}
- 同步代码块的形式使用。
private void count() {
synchronized (this) {
if (count > 0) {
Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
} else {
isRunning = false;
}
}
}
（2） 特殊域变量volatile修饰变量：告诉虚拟机该变量随时可能更新，因此使用时每次都会重新计算，而不是使用寄存器的值。volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。(不能完全保证线程安全)
private volatile int count = 1000;
（3）使用重入锁实现线程同步。
- ReentrantLock() : 创建一个ReentrantLock实例
- lock() :获得锁
- unlock() : 释放锁
private void count() {
lock.lock();
if (count > 0) {
Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
} else {
isRunning = false;
}
lock.unlock();
}
（4）ThreadLocal管理变量。如果一个变量使用ThreadLocal进行管理，每一个使用该变量的线程都会获得该变量的副本，副本之间相互独立，所以每个线程都可以修改变量而不会对其它线程造成影响。
private static ThreadLocal<Integer> number = new ThreadLocal<Integer>(){
// 重写方法，设置默认值
@Override
protected Integer initialValue() {
return 1;
}
// 自定义方法设置变量值
public void saveNumber(int newNumber){
number.set(number.get() + newNumber);
}
// 自定义方法获取变量值
public int getNumber(){
return number.get();
}
};
相关文章：
Android多线程：理解和简单使用总结
