android线程的介绍及两种启动方式

直接查看Thread的源码代码，注释里面已经清楚的说是两种，方法已经给出来

There are two ways to create a new thread of execution. One is to
* declare a class to be a subclass of Thread. This
* subclass should override the run method of class
* Thread. An instance of the subclass can then be
* allocated and started. For example, a thread that computes primes
* larger than a stated value could be written as follows:

一种是直接继承Thread类：（代码直接是复制Thread类中官方给的）
 

*     class PrimeThread extends Thread {
 *         long minPrime;
 *         PrimeThread(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }

调用
 *     PrimeThread p = new PrimeThread(143);
 *     p.start();

第二种是实现Runable接口

 *     class PrimeRun implements Runnable {
 *         long minPrime;
 *         PrimeRun(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }


 *     PrimeRun p = new PrimeRun(143);
 *     new Thread(p).start();

         Thread类是真正java语言对线程的一个抽象类（java 是面向对象开发的，万物皆为对象）

        Runnable 类是对任务的抽象

    继承Thread类之后，由于 Java单继承的特点，当前的类就不能继承其他的类。但是实现     Runnable接口，就可以继承其他类。

由于Runnable是一个任务对象，所有他可以实现多个线程共享一个任务对象，而Thread不行

    stop()方法 ，上添加了一个 @Deprecated 废弃的注解，所以不推荐使用

 @Deprecated    
    public final void stop() {

   stop方法是一种野蛮的关闭，会导致线程所占用的资源 不会正确的释放资源。

  正确停止线程的方法：

interrupt（）不是正真的中止线程，他其实是给当前线程一个中断的标志位，线程不会中止，也可以不用理会，这个由线程自己来决定是否关闭。

isInterrupted() 这个方法就是用来返回当前线程是否设置了中断的标志位，线程可以通过这个方法来判断是是否响应中断

interrupted() 也是检查当前的线程是否有中断标志位，他是一个静态的方法

public static native boolean interrupted();

    线程的启动都是调用start()方法的；

 public synchronized void start() {
     
        if (started)  //当start()方法调用了两次的时候，直接抛出异常
            throw new IllegalThreadStateException();
        group.add(this);
        started = false;
        try {

            // start0();
            nativeCreate(this, stackSize, daemon);
            started = true;   //线程调用了start()方法后，  started = true; 避免start()方法多次调用
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                
            }
        }
    }

  当正在执行的A线程中调用了线程B的jion()方法后，相当于A线程将cpu的执行权让给了B,等B执行完后再执行，join（）方法将线程串行了。

package com.example.mylibrary;

import java.util.concurrent.Executors;

public class JVmBean {
    public static void main(String[] args) {
        System.out.println("------main------------");
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();
        threadA.start();
        threadB.start();
//        try {
//            threadB.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("------main----end--------");
    }
  static   class ThreadA extends Thread{
        @Override
        public void run() {
            super.run();
            System.out.println("------A------------");
            System.out.println("------end------------");

        }
    }
    static  class ThreadB extends Thread{
        @Override
        public void run() {
            super.run();
            System.out.println("------B------------");
            try {
                Thread.currentThread().sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------B-----end-------");
        }
    }






}

输出结果：

------main------------
------main----end--------
------A------------
------end------------
------B------------
------B-----end-------

然后我们让B加入join方法后：很明显主线程得等B线程执行完后再执行

   ------main------------
------A------------
------end------------
------B------------
------B-----end-------
------main----end--------