Thread部分总结以及小例子

Thread总结：一直以来用thread比较多，一般会在同步以及ui中用到．以下对于经常用作为简单介绍．

一　实现方法：

一种直接new thread，另外一种是实现Runnable接口，在创建thread的时候将Runnable直接丢进去即可．另外从java的唯一继承性那么用runnable更适合．

Example:

public class MainActivity extends Activity {
    Thread thread1;
    Thread thread2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        operateThread();
        thread1.start();
        thread2.start();
    }

    public void operateThread(){
       Log.d("ThreadTest", "threadGroup");
       thread1 = new Thread(new Runnable(){
           public void run(){
               while(true){
                   Log.d("ThreadTest","thread_1.running: ");
                   try {
                       Thread.sleep(4000);
                   } catch (InterruptedException e) {
                       // TODO Auto-generated catch block
                       e.printStackTrace();
                   }
               }
           }
       });

        class MyRunnable implements Runnable {
           public void run(){
               while(true){
                   Log.d("ThreadTest","thread_2.running: ");
                   //Thread.yield();
                   try {
                       Thread.sleep(4000);
                   } catch (InterruptedException e) {
                       // TODO Auto-generated catch block
                       e.printStackTrace();
                   }
               }
           }
        }
       thread2 = new Thread(new MyRunnable());
    };

运行结果：
04-25 15:05:38.299 28518 28518 D ThreadTest: threadGroup
04-25 15:05:38.301 28518 28536 D ThreadTest: thread_1.running:
04-25 15:05:38.319 28518 28537 D ThreadTest: thread_2.running:
04-25 15:05:42.302 28518 28536 D ThreadTest: thread_1.running:
04-25 15:05:42.323 28518 28537 D ThreadTest: thread_2.running:

二.方法解说：
　　run()-->线程运行时所执行的代码
　start()-->用于启动线程
　sleep(long millis)-->线程休眠，交出CPU，让CPU去执行其他的任务，然后线程进入阻塞状态，sleep方法不会释放锁
　　yield()-->使当前线程交出CPU，让CPU去执行其他的任务，但不会进入阻塞状态，而是重置为就绪状态，yield方法不会释放锁．和sleep区别是sleep会阻塞会再执行，yield让出cpu后，和其它线程存在竞争状态．
　　join()-->当前主线程等待其他线程执行完毕后，再来继续执行Thread.join()后面的代码
　　interrupt()//中断线程，自stop函数过时之后，我们通过interrupt方法和isInterrupted()方法来停止正在运行的线程，注意只能中断已经处于阻塞的线程
　getId()-->当前线程id
　getName()/setName()-->获取和设置线程的名字
　getPriority()/setPriority()-->获取和设置线程的优先级，property用1-10整数表示，默认优先级是5，优先级最高是10，优先级高的线程被执行的机率高
　　setDaemon()/isDaemo()//设置和判断是否是守护线程
　　currentThread()-->静态函数获取当前线程
　　wait()/notyfy／notifyAll-->他们是属于Obeject对象，不是属于线程。它们用在线程同步时synchronized语句块中。wait交出cpu，让CPU去执行其他的任务，线程进入阻塞状态，同时也会释放锁．notify()并不会让当前线程休眠，但会唤醒休眠的线程。（notifyAll方法就会通知所有等待这个对象控制权的线程继续运行）
　　　　eg:wait():我等会儿再用这把锁，CPU也让给你们，我先休息一会儿！notify()意思是说，我用完了，你们谁用？

关于wait && notify的简单例子如下：
public class MainActivity extends Activity {
    Thread thread1;
    Thread thread2;
    boolean threadRunning;
    final Object object = new Object();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        operateThread();
｝
    public void operateThread(){
       Log.d("ThreadTest", "threadGroup");
       thread1 = new Thread(new Runnable(){
           public void run(){
               synchronized (object) {
                   threadRunning = true;
                   for(int i =0;i <= 100;i++){
                       Log.d("ThreadTest","thread_1.running: i: " + i);
                       if(i== 50){
                           try {
                           object.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       }
                   }
                   threadRunning = false;
               }
           }
       });
       thread1.start();

        class MyRunnable implements Runnable {
           public void run(){
           synchronized (object) {
               for(int i=0;i<100;i++){
                   Log.d("ThreadTest","thread_2.running: i: " + i);
                   if(i== 50){
                       object.notify();
                   }
               }
              }
           }
        }
       thread2 = new Thread(new MyRunnable());
       thread2.start();
04-26 10:33:32.376 4956 4956 D ThreadTest: threadGroup
04-26 10:33:32.379 4956 4976 D ThreadTest: thread_1.running: i: 0
　　　　　　．．．．．．中间thread_1一直在运行，由于有object的占用
04-26 10:33:32.381 4956 4976 D ThreadTest: thread_1.running: i: 49
04-26 10:33:32.381 4956 4976 D ThreadTest: thread_1.running: i: 50//到50就释放锁，让出cpu，进入wait阻塞状态
04-26 10:33:32.381 4956 4977 D ThreadTest: thread_2.running: i: 0
　　　　　　．．．．．．．．thread_2获取锁后运行，
04-26 10:33:32.382 4956 4977 D ThreadTest: thread_2.running: i: 50
　　　　　　．．．．．．．．thread_2在50的时候notify持有object对象的线程后，不释放锁，以及不会让出cpu
04-26 10:33:32.382 4956 4977 D ThreadTest: thread_2.running: i: 51
04-26 10:33:32.383 4956 4977 D ThreadTest: thread_2.running: i: 99
　　　　　　．．．．．．．线程2执行完后线程1运行
04-26 10:33:32.384 4956 4976 D ThreadTest: thread_1.running: i: 51
04-26 10:33:32.384 4956 4976 D ThreadTest: thread_1.running: i: 52

　　Thread线程主要状态
（1） New 实例化tread后就是new状态
（2） Runnable 调用start后处于runnable
（3） Running 调用start后切被cpu执行
(4) Blocked 调用join()、sleep()、wait()使线程处于Blocked状态
(5) Dead    线程的run()方法运行完毕或被中断或被异常退出，线程将会到达Dead状态