线程相关知识[2]

一、线程方法

1.1 start():启动线程

start()：作用是启动一个新的线程，但start()方法不能重复调用

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
 
       //线程组概念。已经被线程池替代
        group.add(this);
 
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
 
    private native void start0();

start方法启动子线程是通过调用native的系统提供的方式来启动线程

1.2 run():子线程执行体

作用是将所有的子线程业务逻辑在run方法中实现，在调用start方法时，会启动子线程并自动调用到run方法。不需要显性调用。
单独调用run()方法，会在当前线程中执行run()方法，并不会启动新线程

1.3 yield():线程让步

作用：是暂停当前的线程的执行，并让步于其他同优先级或更高优先级线程，让其他线程先执行

public static native void yield();

方法特点：

1、yield方法是Thread类的静态方法，通过Thread.yield()调用
2、能够让正在执行的线程由“运行状态”进入到“就绪状态”，等待CPU调度。
3、正在执行线程让步于相同优先级或更高优先级的线程来获取CPU执行权，当同级优先级或者更高优先级没有对应线程时，当前线程又可以继续执行

1.4 sleep():线程休眠

作用：让线程休眠，哪个线程调用sleep方法，哪个线程休眠

public static native void sleep(long millis) throws InterruptedException;
 
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) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
 
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
 
        sleep(millis);
    }

sleep方法有两个，分别是sleep(long millis)和sleep(long millis, int nanos)，两个方法功能一样，第二个方法提供了纳秒级的时间控制

特点：
1、sleep方法是静态的native方法，调用Thread.sleep()调用
2、sleep方法调用会使当前线程从“运行状态”进入到“睡眠状态”，直到给定的时间millis，当前线程才会被唤醒
3、sleep方法会使线程休眠到指定的时间，如果要提前终止休眠，可以通过Interrupt方法调用，会使当前的sleep方法抛出InterruptedException异常，结束掉休眠

1.5 join():线程合并

作用：暂停当前线程，等待子线程执行结束当前线程才能执行。join方法让并行的线程合并为串行的线程执行

例如：a线程中执行代码b.join()方法，则a线程会停止当前执行，并让b线程线执行，直到b线程执行结束，a线程才继续执行

//指定合并等待时间
public final synchronized void join(long millis) throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
 
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
 
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
 
 //指定毫秒、纳秒界别的合并时间
    public final synchronized void join(long millis, int nanos) throws InterruptedException {
 
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
 
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
 
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
 
        join(millis);
    }
 
    //会一直等待直到子线程执行结束
    public final void join() throws InterruptedException {
        join(0);
    }

方法特点：
1、线程方法提供了三种方法join(long millis)、join(long millis, int nanos)和join()方法，都是调用了join(long millis)的实现
2、join方法定义在Thread类中，可以抛出InterruptedException异常，即join方法是可以被中断合并
3、join方法调用会使线程状态从“运行状态”进入到“阻塞状态”
4、join方法可以使线程按照顺序串行执行

1.6 Interrupt():中断线程

作用：中断当前线程，中断处于阻塞状态的线程

方法：

boolean isInterrupted()  //返回值：true：当前线程被中断  false：当前线程未被中断
void interrupt();        //发起中断操作 是Thread类中的普通方法，由对象调用该方法

源码实现：

public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
 
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }
private native void interrupt0(); //底层操作系统提供中断业务

方法说明：
中断操作interrupt()方法底层调用的是native的interrupt0()方法，发起中断操作仅仅修改中断标志位
1、如果当前的线程处于阻塞状态（sleep、join、wait等方法会导致线程进入阻塞状态），在任意的其他线程调用Interrupt（）方法，那么线程会立即抛出一个InterruptedException退出阻塞状态
2、如果当前的线程处于运行状态，其他线程调用Interrupt方法，当前线程继续运行，直到发生了阻塞之后随后会立即抛出异常跳出阻塞

1.7 daemon():守护线程

方法介绍：

void setDaemon(boolean on)  //设置守护线程， 参数Boolean类型 true：设置为守护线程 false：非守护线程 默认是false
  boolean isDaemon()  //判断当前线程是否为守护线程

守护线程：
Java中有两种线程，用户线程(非守护线程) 和 守护线程，通过isDaemon方法进行区分，如果返回是false：说明线程是用户线程，否则是”守护线程“
用户线程一般用户执行用户级的任务
守护线程也称之为”后台线程“，服务于用户线程，一般执行后台任务，例如：垃圾回收的线程是单独线程来处理的，负责垃圾回收的线程就是守护线程

线程生命周期：
守护线程是依赖于用户线程，当用户线程存在时，守护线程就会存活，当没有了用户线程时，那么守护线程也就会随之消亡

1.8 Priority:线程优先级

用来指导线程的执行优先级的，指的是用来告诉CPU哪些线程优先被执行
方法介绍：

void setPriority(int newPriority) //设置当前线程的优先级，newPriority必须是1~10之间的整数，否则会抛出异常
int getPriority() //获取当前线程的优先级
 public final static int MIN_PRIORITY = 1; //最小优先级
 public final static int NORM_PRIORITY = 5;//默认优先级
 public final static int MAX_PRIORITY = 10;//最大优先级

优先级的特点：
1、Java的线程的优先级并不是绝对的，其控制的是执行的机会，优先级高的线程被执行的概率比较大，而优先级低的线程也并不是没有机会，只是执行的概率相对低一些
2、Java线程的优先级一共10个级别，分别为1-10，数值越大，表明优先级越高，一个普通的线程，其优先级为5（即为默认优先级）

二、线程调度

2.1 方法级调度

Java线程中提供的一些方法可以进行线程的调度，合理的线程方法使用，可以充分发挥系统的性能，提高程序的执行效率

1.线程的优先级：高优先级线程获得较多的运行机会
2.线程睡眠：sleep()，让当前线程从运行状态进入到阻塞状态
3.线程让步：yield()，让正在执行的线程从运行状态进入就绪状态
4.线程合并：join()，当前调用join方法的线程进入到运行状态
5.线程等待：wait()，会使线程从运行状态进入到等待状态

2.2 系统级调度

主要指系统在特定的时机自动进行调度，主要涉及调度算法

• FIFO：先进先出算法
• SJF：最短作业优先算法
• SRTF:最短剩余时间优先算法
• RR（Round Robin）：时间片轮转算法
• HPF(Higest Priority First):最高优先级算法

OS系统调度算法一般都是基于时间片的优先级算法