android中线程Thread

线程包括几个状态
创建（new)    Thread thread=new Thread;

就绪（runnable） thread.start();

运行（running） 线程只能从就绪状态进入到运行状态

阻塞（blocked） 该状态是线程因为某种原因放弃了cpu使用权限，暂时停止运行
 

阻塞的情况有三种：
1）等待：调用了wait(),线程进入等待阻塞状态。此时线程需要等待某项工作的完成
2）同步：当线程获取synchronized同步锁失败（此时锁被其他线程暂时占用），线程进入同步阻塞状态。此时该线程需要等其他线程使用完锁。
3）其他：当调用了sleel()或join()或发出了I/O请求时，线程进入阻塞状态。此时线程需要等sleep()时间结束或被打断、join()中断、I/O处理完成，线程才能重新进入就绪状态。
 

• 消亡（dead）

1)线程中run()或call()执行完成，正常结束
2)线程抛出Exception或error，异常退出
3)线程调用stop()结束—容易导致死锁，不建议

注意：同一时刻线程都只有一种状态，通过线程中getState方法可以获取线程的状态。

 二.线程创建的三种方式

1)继承Thread

private class MyThread extends Thread {
    SyncThread(String name) {
        super(name);
    }
    @Override
    public void run() {
       //执行耗时操作
    }
}
 

2)实现Runnable接口

private class MyThread implements Runnable {
        @Override
        public void run() {
            //执行耗时操作
        }
    }

3） 匿名内部类创建线程

new Thread(new Runnable() {
            public void run() {
               //执行耗时操作
            }
}).start();
 

三.线程间通信

1.Handler机制

//主线程中定义handler 
handler=new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
               //ui更新操作
                }
            }
        };
//开启子线程，通过handler.sendMessage（）发消息，通知handler完成ui更新
new Thread(){
            @Override
            public void run() {
                super.run();
                for (int i=0;i<3;i++){
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Message message=new Message();
                message.what=1;
                message.obj="消息";
                handler.sendMessage(message);
            }
 }.run();
注意： Handler对象必须定义在主线程中，如果是多个类直接互相调用，就不太方便，需要传递content对象或通过接口调用。
弊端： Handler机制与Activity生命周期不一致的原因，容易导致内存泄漏，不推荐使用。

2.runOnUiThread

 new Thread(){
        @Override
        public void run() {
            super.run();
            for (int i=0;i<3;i++){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
  runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    //ui更新操作
                }
            });
        }
    }.run();

用Activity对象的runOnUiThread方法更新，在子线程中通过runOnUiThread()方法更新UI，强烈推荐使用。

3.View.post(Runnable r)

new Thread(){
        @Override
        public void run() {
            super.run();
            for (int i=0;i<3;i++){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
 tv.post(new Runnable() {
         @Override
          public void run() {
           //ui更新操作
           }
       });  }
}.run();
这种方法更简单，但需要传递要更新的View过去,推荐使用

4.AsyncTask

new AAsyncTask().execute("消息");

private class AAsyncTask extends AsyncTask{
        @Override
        protected Object doInBackground(Object[] objects) {
            for (int i=0;i<3;i++){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return objects[0].toString();
        }
        @Override
protected void onPostExecute(Object o) {
            super.onPostExecute(o);
            //ui更新操作
        }
    }
四.Thread线程同步

1）为什么需要线程同步？

防止多个线程访问一个数据对象时，出现数据不一致的问题。

2）线程同步的几种方式

1）同步函数同步函数 

private synchronized void count() {
    if (count > 0) {
        Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
    } else {
        isRunning = false;
    }
}

2）同步代码块

 private void count() {
    synchronized (this) {
        if (count > 0) {
            Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
        } else {
            isRunning = false;
        }
    }
}

3）使用特殊域变量(volatile)实现线程同步

   private volatile int count = 1000;

4）使用重入锁实现线程同步

 private void count() {
        lock.lock();
        if (count > 0) {
            Log.e(TAG, Thread.currentThread().getName() + "--->" + count--);
        } else {
            isRunning = false;
        }
        lock.unlock();
    }
 

五，操作线程的方法

5.1 线程的休眠(sleep)
使用sleep()方法时，必须加入InterruptedException异常捕捉，使用sleep()方法的会使线程进入睡觉状态，也就是上面提到的阻塞状态，接收的参数是毫秒，在设定的毫秒时间内醒来后，它并不能保证能进入运行状态，只能保证它进入就绪状态。

现在已经不提倡使用stop方法来停止线程，因为那是不安全的，最好的停止线程方式是定义一个类成员变量，然后在循环过程中去判断此变量是否为假，便退出当前循环。但如果线程正在sleep()或wait()中，便无法使用类成员变量来判断，此时可以使用interrup()方法离开run()方法，同时结束线程，但程序会抛出InterruptedException异常。使用如下：

class MyThread extends Thread {
    volatile boolean mStop = false;         //volatile修饰变量一种轻量级的同步机制
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted() && !mStop) {
            try {
                Thread.sleep(1000);
                // TODO...
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
// 启动线程
MyThread myThread = new MyThread();
myThread.start();
// 停止线程
myThread.mStop = true;
myThread.interrupt();

 Java提供了中断机制，Thread类下有三个重要方法：

public void interrupt()方法可用于外部或者线程内部进行中断标记，它不会真正中断正在运行的线程，只是发出一个请求，由线程在合适的时候结束自己。如果存在sleep则会抛出InterruptedException异常。
public boolean isInterrupted()方法用于判断中断标记是否为true。
public static boolean interrupted()方法用于清除中断标志，并返回原状态。

5.3 线程的加入(join)
假如存在线程A和线程B，线程A正在运行状态，而现在要求线程A先暂停，让线程B先执行完毕，然后再继续执行线程A，此时就应使用join()方法来完成。这就好比你正在看电视，却突然有人上门送快递，那么您就先开门签收快递后再继续看电视一样。使用如下：

Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("[" + Thread.currentThread().getName() + "] Hello...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});
t.start();
try {
    t.join();
} catch (Exception e) {
    e.printStackTrace();
}
System.out.println("[" + Thread.currentThread().getName() + "] Hello...");
输出结果是：

[Thread-0] Hello...
[main] Hello...
————————————————

5.4 线程礼让(yield)
yield()方法使当前线程让出CPU占有权，使正在运行中的线程重新变成就绪状态，并重新竞争 CPU 的调度权。那么同样优先级的线程就有了可执行状态的机会。对于支持多任务的操作系统来说，不需要调用yeild()方法，因为操作系统会为线程自动分配CPU时间片来执行。

另外要注意的是，yield并不会释放锁标志。