打卡百天计划第二天-线程API

sleep方法

public static void sleep(long millis) throws InterrupedException

public static void sleep(long millis,int nanos) throws InterrupedException	

sleep方法会使当前线程进入指定的毫秒休眠，不会放弃monitor锁的所有权。 最好用TimeUnit代替sleep,省去了时间的换算。

Thread.sleep(50);
TimeUnit.SECENS.sleep(1);
TimeUnit.HOUR.sleep(1);
TimeUnit.MILISECONS.sleep(100);
TimeUnit.MINUTES.sleep(1);

yidld方法

yield方法属于一种启发式的方法，其会提醒调度器我愿意放弃当前的CPU资源，如果CPU的资源不紧张，则会忽略这种提醒。

package day0518;

import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

/**
 * @author liw
 * @date 2020-06-16
 */
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        IntStream.range(0, 2).mapToObj(Demo1::create).forEach(Thread::start);
    }

    private static Thread create(int index) {
        return new Thread(() -> {
            
            //if (index == 0) Thread.yield();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(index);
        });
    }
}

上面的程序运行很多次，你会发现输出结果不一致，有时0最先打印出来，有时1最先被打印出来。但是加入yield之后顺序就会始终 是0，1。

yidle与sleep的区别：
1 sleep会导致当前线程暂停指定的时间，没有CPU时间片的消耗。
2yield只是对CPU调度器的一个提示，如果 CPU调度器没有忽略这个提示会导致线程上下文的切换。
3sleep会使 线程block，会在 给定时间内释放CPU资源。
4yield会使RUNNING状态的Thread进入RUNNABLE状态（如果CPU调度没有忽略这个提示的话）。
5sleep几乎百分百的完成指定时间的休眠，而yield的提示并不能一定担保。
6一个线程sleep而另一个线程调用interr会捕获到中断信号，而yield不会。

线程的优先级

public final void setPriority(int new Priority)

public final int getPriority()

◆线程的优先级为 1-9 。
◆线程优先级高于所在Group优先级，线程优先级会失效，取而代之的是Group的优先级。

获取线程ID

public long getId（）

获取当前线程

public static Thread currentThread()

用于返回当前线程的引用。

//实例代码
String name = Thread.currentThread().getName();

设置上下文类加载器

public ClassLoader getContextClassLoader()

public void setContextClassLoader(ClassLoader cl)

interrupt 中断方法

线程interrupt ，是一个非常重要 的 API，也是经常使用的方法，与线程中断相关的API如下几个：

public void interrupt()
public static boolean interrupt()
public bloolean isInterrupt()

如下方法的调用会让线程进入阻塞状态，而调用当前线程的interrupt方法，就可以打断阻塞。
◆Object 的wait方法
◆Object 的wait(long)方法
◆Object 的wait(long,int)方法
◆Thread 的sleep方法
◆Thread 的join方法
◆Thread 的join(long)方法
◆Thread 的join(long，int)方法
◆InterruptibleChannel 的io操作
◆Selector 的wakeup方法

一旦线程在阻塞状态被打断，都会抛出一个InterruptException的异常，这个异常就像一个signal一样通知当前线程被打断了。

package day0518;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author liw
 * @date 2020-06-10
 */
public class Demo1Test1Thread {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                TimeUnit.MINUTES.sleep(1);
            } catch (InterruptedException e) {
                System.out.println("线程被打断了");
            }
        });
        thread.start();
        TimeUnit.MICROSECONDS.sleep(2);
        thread.interrupt();
    }




}

上面的代码线程企图休眠一分钟，但是大约2毫秒之后被主线程调用interrupt方法打断。

isInterrupted 方法

判断当前线程是否被中断。仅是对interrupt标识的一个判断，并不会影响标识发生任何改变，这点与interrupted是存在差异的。
可中断方法捕获到中断信号后，也就是捕获到InterruptedException 异常之后会擦除掉Interrupt的标识。

interrupted方法

interrupted是一个静态方法，虽然也用于判断当前线程是否被中断，但是它和成员方法isInterrupted还是有很大的区别，调用该方法会直接擦除掉线程的interrupt标识，如果当前线程被打断了，那么第一次使用interrupted方法会返回true，并且立即擦除interrupt标识；第二次包括以后都会返回false，除非在此期间线程又一次被打断。

join 方法

public final void join() throws InterruptedException 
public final synchronized void join (long millis,int nanos)
public final synchronized void join (long millis)

join某个线程A，会使当前线程B进入等待，知道线程A结束生命周期，或者达到给定的时间，那么在此期间B线程是处于BLOCKED的，而不是A线程。

package day0518;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author liw
 * @date 2020-06-10
 */
public class Demo1Test1Thread {

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threads = IntStream.range(1,3).mapToObj(Demo1Test1Thread::create).collect(Collectors.toList());
        threads.forEach(Thread::start);

        for (Thread e:threads) {
            e.join();
        }

        for (int i =0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"#"+i);
            shortSleep();
        }

    }

    private static Thread create(int seq){
        return new Thread(()->{
            for (int i =0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"#"+i);
                shortSleep();
            }
        },String.valueOf(seq));
    }

    private static void shortSleep(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }



}

2#0
1#0
1#1
2#1
2#2
1#2
1#3
2#3
2#4
1#4
1#5
2#5
1#6
2#6
1#7
2#7
1#8
2#8
1#9
2#9
main#0
main#1
main#2
main#3
main#4
main#5
main#6
main#7
main#8
main#9

Process finished with exit code 0