书接上文。上文主要讲了下线程的基本概念,三种创建线程的方式与区别,还介绍了线程的状态,线程通知和等待,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();
    }
}

运行结果:
并发编程基础(下)-LMLPHP

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

当我们调用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();
    }
}

运行结果:
并发编程基础(下)-LMLPHP

当然在一般情况下,可能永远也不会用到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();
    }
}

当我们运行后,可以发现程序一直没有退出:
并发编程基础(下)-LMLPHP
因为这是用户线程,只要有一个用户线程还没结束,程序就不会退出。

再来看看守护线程:

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

当我们运行后,发现程序立刻就停止了:
并发编程基础(下)-LMLPHP
因为这是守护线程,当用户线程结束后,不管有没有守护线程还在运行,程序都会退出。

线程中断

之所以把线程中断放在后面,是因为它是并发编程基础中最难以理解的一个,当然这也与不经常使用有关。现在就让我们好好看看线程中断。
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();
  }
}

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

isInterrupted

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

interrupted

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

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

05-06 13:54