Thread基本方法介绍

待更新

1. java.lang.SecurityManager;

Thread中基本方法

1.void suspend()方法

　　这是一个过期的方法，与void resume()搭配使用来暂停和唤醒一个线程。这两个方法有可能形成独占和不一样步的问题—详见《java多线程编程核心技术》。方法源码以下：

@Deprecated
    public final void suspend() {
        checkAccess();
        suspend0();
    }

　　首先当前线程的checkAccess()方法被调用，其有可能致使SecurityException。若是当前线程时活跃着的，则挂起，调用resume()方法激活。相关方法checkAccess()和suspend0()源码以下：

/**
 *检测当前运行的线程是否有权限修改这个线程
 *    好比main线程使用代码someThread.suspend()来修改someThread线程；
 *若是有 安全管理器/SecurityManagy，则将被修改的线程做为参数调用安全管理器的    
 *checkAccess方法。
 *
 *若是当前线程没有权限修改被修改的线程，则抛出SecurityException异常。
 */
    public final void checkAccess() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkAccess(this);
        }
    }

　　native指Java调用本地方法，一般为非java语言实现

private native void suspend0();//原来源码名称后缀数字的是这个意思

　　resume()方法同理，也是一个过期的唤醒线程的方法。若是当前线程没有权限修改被唤醒的线程，则抛出SecurityException异常
　　

@Deprecated
    public final void resume() {
        checkAccess();
        resume0();
    }

2.void yield()

Thread.yield()是指当前线程已经完成重要操做，建议线程调度器将cpu资源从转移给另外一个线程：
　　

public static native void yield();

3.线程优先级

　　线程优先级为1~10，数字越高表明级别越高优先级越高。Thread类中设置了三个默认的优先级属性：
　　

/**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

当咱们在使用void setPriority(int newPriority) 设置线程的优先级时，数字必须在这个区间。方法源码以下：

/**
 *final方法：不能被改写；final类不能被继承；
 *
 *
 *
 */
    public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();//检查当前线程是否有修改此线程优先级的权限；
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {//优先级必须在[1,10]之间，不然抛异常：非法参数
            throw new IllegalArgumentException();
        }
        //fixme 返回被修改线程所在的线程组，若是被修改线程结束则返回null。若是要设置的值大于所在组线程的能够有的最大值，则自动下降为当前线程组已有的最大值。
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }

　　这里有一个须要注意的点：若是要设置的值大于所在组线程的能够有的最大值，则自动下降为当前线程组已有的最大值。除此以外：
　　1.线程具备继承性，即被建立的线程与其建立者具备相同的优先级；
　　2.线程优先级即具备“规则性”，又具备“随机性”，即优先级高的线程有限执行，但其run()方法中任务又不必定是最早执行完。cup只是尽可能将资源让给优先级比较高的线程，可是代码先运行、优先级高的线程不必定最早执行完。
　　综上，线程的优先级具备1.组自贬性；2.继承性；3.随机性

4.守护进程：setDaemon(boolean )

　　守护进程也可理解为“保姆进程”，当所须要服务的“雇主进程们”结束了，保姆进程自动销毁。最典型的守护进程是GC垃圾回收器。调用Thread 的setDaemon(boolean ）方法传参true将进程设置为守护进程，此方法只能在start()调用之间调用，即进程为非存活的状态下。方法源码以下：

public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) {//若是当前线程已经经过start()方法激活，则不能在更改其类型。
            throw new IllegalThreadStateException();
        }
        daemon = on;//daemon是Thread类变量，标识其是不是守护进程
    }

五.中止线程:作标记，三方法抛异常清除，短方法清除

中止一个线程使用interrupt()方法
除非线程要中断自己。此操做是为当前线程作标识“能够中止”，而非真正的中止线程。

若是线程在调用wait()、join()、sleep()及其各类变参多态函数后，再调用interrupt()方法会清空其interurpted的状态，并抛出InterruptedException异常。

线程是不是“可中止状态”能够调用两个方法：

1. boolean interrupted():会清除“可中止状态”，测试的是当前线程；

2.boolean isInterrupted()：不会清除状态，测试的是Thread对象；

//参数表示返回其当前状态后是否将其从新设置为“不可中止”
private native boolean isInterrupted(boolean ClearInterrupted);

两个方法源码以下：

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

    public boolean isInterrupted() {
        return isInterrupted(false);
    }

　　中止线程书中讲解了三种方式：

1. 异常法；
2. 在沉睡中中止；
3. 在这里不作讲解的stop()暴力中止；

异常法即当咱们使用interrupted()（当前current线程）已经标记为“可中止”时，能够在run()方法中抛出异常并在run()方法的最后捕获异常，以此来中止线程。示例代码以下：

public DemoClass extends Thread{
    @Override
    public void run(){
        try{
            //doSomeThing
            if(this.interrupted()){
                throw new InterruptedException();
            }
        }catch(InterruptedException e){
            //doSomeThing
        }
    }
}

　　正如咱们上边讲的，若是线程调用wait()、join()、sleep()后再调用interrupt()方法，会清空中止状态并抛异常InterreptedException。使用这个方法也能够中止线程，其实与第一个差很少，我以为。

六.获取线程id：long getId();

七.让线程休眠指定时间

　　调用sleep(long million)或者sleep(long millis,int nans)可使调用方法的线程休眠指定时间，方法可能抛出InterruptedException和IllegalArgumentException，源码以下：

//使当前线程休眠指定毫秒：1秒=1000毫秒
    public static native void sleep(long millis) throws InterruptedException;

/**
 *使线程休眠指定毫秒+纳秒，其实精确不了纳秒的级别：
 *  1.若是纳秒参数>500,000则休眠时间增长1毫秒（至关于向上取整）;
 *  2.若是毫秒参数为0并且纳秒参数不为0，则休眠1毫秒；
 *  3.纳秒级别的参数不能超过1毫秒,即999，999；
 *  1ms=1000,000ns（纳秒）
 *
 **/
    public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {//纳秒级别的参数不能超过1毫秒
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }

八.检测线程是否“存活”

　　方法源码以下，若是当前线程正在运行或者准备运行都会返回true：

public final native boolean isAlive();

九.返回当前正执行线程的引用

public static native Thread currentThread();