android 线程的状态

来源：互联网发布：开源销售管理系统 php 编辑：程序博客网时间：2024/06/11 00:12

1,线程

1.1线程的状态

线程在它的生命周期中可能处于以下几种状态之一：

· New（新生）：线程对象刚刚被创建出来；

· Runnable（可运行）：在线程对象上调用start方法后，相应线程便会进入Runnable状态，若被线程调度程序调度，这个线程便会成为当前运行（Running）的线程；

· Blocked（被阻塞）：若一段代码被线程A”上锁“，此时线程B尝试执行这段代码，线程B就会进入Blocked状态；

· Waiting（等待）：当线程等待另一个线程通知线程调度器一个条件时，它本身就会进入Waiting状态；

· Time Waiting（计时等待）：计时等待与等待的区别是，线程只等待一定的时间，若超时则不再等待；

· Terminated（被终止）：线程的run方法执行完毕或者由于一个未捕获的异常导致run方法意外终止会进入Terminated状态。

1.2 线程的优先级

· 每个线程都有一个优先级，默认情况下，线程会继承它的父线程的优先级。可以用setPriority方法来改变线程的优先级。定义了三个描述线程优先级的常量：MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY。

· 每当线程调度器要调度一个新的线程时，它会首先选择优先级较高的线程。然而线程优先级是高度依赖与操作系统的，因此不应该将程序逻辑的正确性依赖于优先级。

void setPriority(int newPriority) //设置线程的优先级，可以使用系统提供的三个优先级常量static void yield() //使当前线程处于让步状态，当存在其他优先级大于等于本线程的线程时，线程调度程序会调用那个线程

2,Thread方法

2.1 sleep方法

让当前线程进入休眠状态（但线程不会释放已获取的锁），这个休眠状态其实就是Time Waiting状态，从休眠状态“苏醒”后，线程会进入到Runnable状态。

public static void sleep(long time) throws InterruptedException {        Thread.sleep(time, 0);    }

public static void sleep(long millis, int nanos) throws InterruptedException {        if (millis < 0) {            throw new IllegalArgumentException("millis < 0: " + millis);        }        if (nanos < 0) {            throw new IllegalArgumentException("nanos < 0: " + nanos);        }        if (nanos > 999999) {            throw new IllegalArgumentException("nanos > 999999: " + nanos);        }        // The JLS 3rd edition, section 17.9 says: "...sleep for zero        // time...need not have observable effects."        if (millis == 0 && nanos == 0) {            // ...but we still have to handle being interrupted.            if (Thread.interrupted()) {              throw new InterruptedException();            }            return;        }        long start = System.nanoTime();        long duration = (millis * NANOS_PER_MILLI) + nanos;        Object lock = currentThread().lock;        // Wait may return early, so loop until sleep duration passes.        synchronized (lock) {            while (true) {                sleep(lock, millis, nanos);                long now = System.nanoTime();                long elapsed = now - start;                if (elapsed >= duration) {                    break;                }                duration -= elapsed;                start = now;                millis = duration / NANOS_PER_MILLI;                nanos = (int) (duration % NANOS_PER_MILLI);            }        }    }    private static native void sleep(Object lock, long millis, int nanos);

可以看到,休眠时间在ms的基础上指定了ns数,并且是调用本地的sleep方法实现。

2.2 join方法

join方法，这是一个实例方法，在当前线程中对一个线程对象调用join方法会导致当前线程停止运行，等那个线程运行完毕后再接着运行当前线程。也就是说，把当前线程还没执行的部分“接到”另一个线程后面去，另一个线程运行完毕后，当前线程再接着运行。

无参数的join表示当前线程一直等到另一个线程运行完毕，这种情况下当前线程会处于Wating状态；带参数的表示当前线程只等待指定的时间，这种情况下当前线程会处于Time Waiting状态。

public final void join() throws InterruptedException {        synchronized (lock) {            while (isAlive()) {                lock.wait();            }        }    }

public final void join(long millis) throws InterruptedException {        join(millis, 0);    }

public final void join(long millis, int nanos) throws InterruptedException {        if (millis < 0 || nanos < 0 || nanos >= NANOS_PER_MILLI) {            throw new IllegalArgumentException("bad timeout: millis=" + millis + ",nanos=" + nanos);        }        // avoid overflow: if total > 292,277 years, just wait forever        boolean overflow = millis >= (Long.MAX_VALUE - nanos) / NANOS_PER_MILLI;        boolean forever = (millis | nanos) == 0;        if (forever | overflow) {            join();            return;        }        synchronized (lock) {            if (!isAlive()) {                return;            }            // guaranteed not to overflow            long nanosToWait = millis * NANOS_PER_MILLI + nanos;            // wait until this thread completes or the timeout has elapsed            long start = System.nanoTime();            while (true) {                lock.wait(millis, nanos);                if (!isAlive()) {                    break;                }                long nanosElapsed = System.nanoTime() - start;                long nanosRemaining = nanosToWait - nanosElapsed;                if (nanosRemaining <= 0) {                    break;                }                millis = nanosRemaining / NANOS_PER_MILLI;                nanos = (int) (nanosRemaining - millis * NANOS_PER_MILLI);            }        }    }

2.3 yield方法

yield方法，这是一个静态方法，作用是让当前线程“让步”，目的是为了让优先级不低于当前线程的线程有机会运行，这个方法不会释放锁。

2.4 interrupt方法

这是一个实例方法。每个线程都有一个中断状态标识，这个方法的作用就是将相应线程的中断状态标记为true，这样相应的线程调用isInterrupted方法就会返回true。通过使用这个方法，能够终止那些通过调用可中断方法进入阻塞状态的线程。常见的可中断方法有sleep、wait、join，这些方法的内部实现会时不时的检查当前线程的中断状态，若为true会立刻抛出一个InterruptedException异常，从而终止当前线程。

2.5 wait方法

wait方法是Object类中定义的实例方法。在指定对象上调用wait方法能够让当前线程进入阻塞状态（前提时当前线程持有该对象的内部锁（monitor）），此时当前线程会释放已经获取的那个对象的内部锁，这样一来其他线程就可以获取这个对象的内部锁了。当其他线程获取了这个对象的内部锁，进行了一些操作后可以调用notify方法来唤醒正在等待该对象的线程。

2.6 notify/notifyAll方法

notify/notifyAll方法也是Object类中定义的实例方法。它俩的作用是唤醒正在等待相应对象的线程，区别在于前者唤醒一个等待该对象的线程，而后者唤醒所有等待该对象的线程。

线程的状态转换如下,

0 0