并发编程基础（下）

书接上文。上文主要讲了下线程的基本概念，三种创建线程的方式与区别，还介绍了线程的状态，线程通知和等待，join等，本篇继续介绍并发编程的基础知识。

sleep

当一个执行的线程调用了Thread的sleep方法，调用线程会暂时让出指定时间的执行权，在这期间不参与CPU的调度，不占用CPU，但是不会释放该线程锁持有的监视器锁。指定的时间到了后，该线程会回到就绪的状态，再次等待分配CPU资源，然后再次执行。

我们有时会看到sleep(1)，甚至还有sleep(0)这种写法，肯定会觉得非常奇怪，特别是sleep(0)，睡0秒钟，有意义吗？其实是有的，sleep(1)，sleep(0)的意义就在于告诉操作系统立刻触发一次CPU竞争。

让我们来看看正在sleep的进程被中断了，会发生什么事情：

class MySleepTask implements Runnable{
    @Override
    public void run() {
        System.out.println("MyTask1");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            System.out.println("中断");
            e.printStackTrace();
        }
        System.out.println("MyTask2");
    }
}

public class Sleep {
    public static void main(String[] args) {
        MySleepTask mySleepTask=new MySleepTask();
        Thread thread=new Thread(mySleepTask);
        thread.start();
        thread.interrupt();
    }
}

运行结果：

MyTask1
中断
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at com.codebear.MySleepTask.run(Sleep.java:10)
    at java.lang.Thread.run(Thread.java:748)
MyTask2

yield

我们知道线程是以时间片的机制来占用CPU资源并运行的，正常情况下，一个线程只有把分配给自己的时间片用完之后，线程调度器才会进行下一轮的线程调度，当执行了Thread的yield后，就告诉操作系统“我不需要CPU了，你现在就可以进行下一轮的线程调度了 ”，但是操作系统可以忽略这个暗示，也有可能下一轮还是把时间片分配给了这个线程。

我们来写一个例子加深下印象：

class MyYieldTask implements Runnable {
    @Override
    public void run() {
        for (int i = 10; i > 0; i--) {
            System.out.println("我是" + Thread.currentThread().getName() + "，我分配到了时间片");
        }
    }
}


public class MyYield {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyYieldTask());
        thread1.start();

        Thread thread2 = new Thread(new MyYieldTask());
        thread2.start();
    }
}

运行结果：

image.png

当然由于线程的特性，所以每次运行结果可能都不太相同，但是当我们运行多次后，会发现绝大多数的时候，两个线程的打印都是比较平均的，我用完时间片了，你用，你用完了时间片了，我再用。

当我们调用yield后：

class MyYieldTask implements Runnable {
    @Override
    public void run() {
        for (int i = 10; i > 0; i--) {
            System.out.println("我是" + Thread.currentThread().getName() + "，我分配到了时间片");
            Thread.yield();
        }
    }
}


public class MyYield {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyYieldTask());
        thread1.start();

        Thread thread2 = new Thread(new MyYieldTask());
        thread2.start();
    }
}

运行结果：

image.png

当然在一般情况下，可能永远也不会用到yield，但是还是要对这个方法有一定的了解。

sleep 和 yield 区别

当线程调用sleep后，会阻塞当前线程指定的时间，在这段时间内，线程调度器不会调用此线程，当指定的时间结束后，该线程的状态为“就绪”，等待分配CPU资源。
当线程调用yield后，不会阻塞当前线程，只是让出时间片，回到“就绪”的状态，等待分配CPU资源。

死锁

死锁是指多个线程在执行的过程中，因为争夺资源而造成的相互等待的现象，而且无法打破这个“僵局”。

死锁的四个必要条件：

• 互斥：指线程对于已经获取到的资源进行排他性使用，即该资源只能被一个线程占有，如果还有其他线程也想占有，只能等待，直到占有资源的线程释放该资源。
• 请求并持有：指一个线程已经占有了一个资源，但是还想占有其他的资源，但是其他资源已经被其他线程占有了，所以当前线程只能等待，等待的同时并不释放自己已经拥有的资源。
• 不可剥夺：当一个线程获取资源后，不能被其他线程占有，只有在自己使用完毕后自己释放资源。
• 环路等待：即 T1线程正在等待T2占有的资源，T2线程正在等待T3线程占有的资源，T3线程又在等待T1线程占有的资源。

要想打破“死锁”僵局，只需要破坏以上四个条件中的任意一个，但是程序员可以干预的只有“请求并持有”，“环路等待”两个条件，其余两个条件是锁的特性，程序员是无法干预的。

聪明的你，一定看出来了，所谓“死锁”就是“悲观锁”造成的，相对于“死锁”，还有一个“活锁”，就是“乐观锁”造成的。

守护线程与用户线程

Java中的线程分为两类，分别为 用户线程和守护线程。在JVM启动时，会调用main函数，这个就是用户线程，JVM内部还会启动一些守护线程，比如垃圾回收线程。那么守护线程和用户线程到底有什么区别呢？当最后一个用户线程结束后，JVM就自动退出了，而不管当前是否有守护线程还在运行。
如何创建一个守护线程呢？

public class Daemon {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
        });
        thread.setDaemon(true);
        thread.start();
    }
}

只需要设置线程的daemon为true就可以。
下面来演示下用户线程与守护线程的区别：

public class Daemon {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true){}
        });

        thread.start();
    }
}

当我们运行后，可以发现程序一直没有退出：

image.png

因为这是用户线程，只要有一个用户线程还没结束，程序就不会退出。

再来看看守护线程：

public class Daemon {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true){}
        });
        thread.setDaemon(true);
        thread.start();
    }
}

当我们运行后，发现程序立刻就停止了：

image.png

因为这是守护线程，当用户线程结束后，不管有没有守护线程还在运行，程序都会退出。

线程中断

之所以把线程中断放在后面，是因为它是并发编程基础中最难以理解的一个，当然这也与不经常使用有关。现在就让我们好好看看线程中断。
Thread提供了stop方法，用来停止当前线程，但是已经被标记为过期，应该用线程中断方法来代替stop方法。

interrupt

中断线程。当线程A运行（非阻塞）时，线程B可以调用线程A的interrupt方法来设置线程A的中断标记为true，这里要特别注意，调用interrupt方法并不会真的去中断线程，只是设置了中断标记为true，线程A还是活的好好的。如果线程A被阻塞了，比如调用了sleep、wait、join，线程A会在调用这些方法的地方抛出“InterruptedException”。
我们来做个试验，证明下interrupt方法不会中断正在运行的线程：

class InterruptTask implements Runnable {
    @Override
    public void run() {
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 150000; i++) {
                copyOnWriteArrayList.add(i);
            }
            System.out.println("结束了,时间是" + (System.currentTimeMillis() - start));
            System.out.println(Thread.currentThread().isInterrupted());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

public class InterruptTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new InterruptTask());
        thread1.start();
        thread1.interrupt();
    }
}

运行结果：

结束了,时间是7643
true

在子线程中，我们通过一个循环往copyOnWriteArrayList里面添加数据来模拟一个耗时操作。这里要特别要注意，一般来说，我们模拟耗时操作都是用sleep方法，但是这里不能用sleep方法，因为调用sleep方法会让当前线程阻塞，而现在是要让线程处于运行的状态。我们可以很清楚的看到，虽然子线程刚运行，就被interrupt了，但是却没有抛出任何异常，也没有让子线程终止，子线程还是活的好好的，只是最后打印出的“中断标记”为true。

如果没有调用interrupt方法，中断标记为false：

class InterruptTask implements Runnable {
    @Override
    public void run() {
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 500; i++) {
                copyOnWriteArrayList.add(i);
            }
            System.out.println("结束了,时间是" + (System.currentTimeMillis() - start));
            System.out.println(Thread.currentThread().isInterrupted());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

public class InterruptTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new InterruptTask());
        thread1.start();
    }
}

运行结果：

结束了,时间是1
false

在介绍sleep，wait，join方法的时候，大家已经看到了，如果中断调用这些方法而被阻塞的线程会抛出异常，这里就不再演示了，但是还有一点需要注意，当我们catch住InterruptedException异常后，“中断标记”会被重置为false，我们继续做实验：

class InterruptTask implements Runnable {
    @Override
    public void run() {
        CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
        try {
            long start = System.currentTimeMillis();
            TimeUnit.SECONDS.sleep(3);
            System.out.println("结束了,时间是" + (System.currentTimeMillis() - start));
        } catch (Exception ex) {
            System.out.println(Thread.currentThread().isInterrupted());
            ex.printStackTrace();
        }
    }
}

public class InterruptTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new InterruptTask());
        thread1.start();
        thread1.interrupt();
    }
}

运行结果：

false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at com.codebear.InterruptTask.run(InterruptTest.java:20)
    at java.lang.Thread.run(Thread.java:748)

可以很清楚的看到，“中断标记”被重置为false了。

还有一个问题，大家可以思考下，代码的本意是当前线程被中断后退出死循环，这段代码有问题吗？

Thread th = Thread.currentThread();
while(true) {
  if(th.isInterrupted()) {
    break;
  }
 
  try {
    Thread.sleep(100);
  }catch (InterruptedException e){
    e.printStackTrace();
  }
}

本题来自 极客时间 王宝令 老师的 《Java并发编程实战》

代码是有问题的，因为catch住异常后，会把“中断标记”重置。如果正好在sleep的时候，线程被中断了，又重置了“中断标记”，那么下一次循环，检测中断标记为false，就无法退出死循环了。

isInterrupted

这个方法在上面已经出现过了，就是 获取对象线程的“中断标记”。

interrupted

获取当前线程的“中断标记”，如果发现当前线程被中断，会重置中断标记为false，该方法是static方法，通过Thread类直接调用。

并发编程基础到这里就结束了，可以看到内容还是相当多的，虽说是基础，但是每一个知识点，如果要深究的话，都可以牵扯到“操作系统”，所以只有深入到了“操作系统”，才可以说真的懂了，现在还是仅仅停留在Java的层面，唉。