java多线程高级-线程中断/阻塞（四）

最新推荐文章于 2023-10-10 00:34:47 发布

piaoslowly

最新推荐文章于 2023-10-10 00:34:47 发布

阅读量1k

点赞数

分类专栏： Java多线程全面解刨

本文链接：https://blog.csdn.net/piaoslowly/article/details/81562265

版权

Java多线程全面解刨专栏收录该内容

27 篇文章 6 订阅

订阅专栏

java多线程高级-线程中断/阻塞（四）

线程中断／阻塞：interrupt/LockSupport

在Core Java中有这样一句话：”没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断 “。

线程中断-interrupt

简单定义
每个线程都有一个interrupt status标志位，用于表明当前线程是否处于中断状态。
一般调用Thread.interrupt()会有两种处理方式

遇到一个低优先级的block状态时，比如object.wait(),object.sleep(),object.join()。它会立马触发一个unblock解除阻塞，并throw一个InterruptedException。
其他情况，Thread.interrupt()仅仅只是更新了status标志位。然后你的工作线程通过Thread.isInterrrupted()进行检查，可以做相应的处理，比如也throw InterruptedException或者是清理状态，取消task等。

Thread的interrupt处理的几个方法：

public void interrupt() : 执行线程interrupt事件
public boolean isInterrupted() : 检查当前线程是否处于interrupt,正式检查，并不会做其它操作。
public static boolean interrupted() ： check当前线程是否处于interrupt，并重置interrupt信息。interrupted取消interrupt中断操作，并返回当前是否处于interrupt状态。

interrupt设置线程状态设置status=1，标示线程停止了；
interrupted()做了getStatus()并且把status=0；获取线程的标示状态，然后把状态重制为0；
isInterrupted()只是做getStatus();

Thread.interrupt()并不是真正的停止当前线程，只是标示一下线程的状态为停止。需要在程序中和Thread.interrupted()配合使用，通过程序代码来做相应的停止执行。

代码说明：


class TestRunnable implements Runnable{
    public void run(){
        while(true)
        {
            System.out.println( "Thread is running..." );
            long time = System.currentTimeMillis();
            空循环1s
            while((System.currentTimeMillis()-time < 1000)) {

            }
        }
    }
}


public class ThreadInterruptDome {

    public static void main(String[] args){
        Thread th1=new Thread(new TestRunnable());
        th1.start();
        th1.interrupt();
    }
}

输出结果说明：
Thread is running…
Thread is running…
Thread is running…
Thread is running..
…
不停的往下输出

Thread.interrupt()执行后，如果程序并没有使用Thread.interrupted()做相应处理，Thread.interrupt()其实是没什么卵用的，线程继续执行。

代码片段2

package cn.thread.first.thread;



class TestRunnable implements Runnable{
    public void run(){
        while(true)
        {
            System.out.println( "Thread is running..." );
            if(Thread.interrupted()){//获取线程停止状态
                break;
            }
        }
        System.out.println("线程停止还是可以执行哦。");
    }
}


public class ThreadInterruptDome {

    public static void main(String[] args){
        Thread th1=new Thread(new TestRunnable());
        th1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        th1.interrupt();//设置状态为停止状态
    }
}

输出结果：
Thread is running…
Thread is running…
Thread is running…
Thread is running…
….
线程停止还是可以执行哦。

解说：代码里面做了Thread.interrupted()相应逻辑的判断了，然后break了，但是并不意味着当前线程就停止了，前面已经介绍过了interrupt只是标示一个状态而已，然后另外一头获取状态，仅此而已，获取状态后线程该咋的还是可以咋的，所以break只是跳出了while循环，并不是真正意义上的线程停止了，所以看到了“线程停止了还是执行了”这句。

解决方案：把break替换为return；或者interruptException抛异常。这样最后一句就不会打印了。

代码段3

package cn.thread.first.thread;

class MyThreadStop extends Thread {

    private int temp;

    public MyThreadStop(int temp) {
        this.temp = temp;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("i=" + i);
            if (Thread.interrupted()) {
                System.out.println("线程已经停止了哦");
                break;
            }
        }
        System.out.println(Thread.currentThread().getName() + temp);
    }

}


public class ThreadStopDome {


    public static void main(String orgs[]) {
        MyThreadStop myThread = new MyThreadStop(1);
        myThread.start();
        myThread.interrupt();
        System.out.println("运行完毕");

    }

}

输出结果：
运行完毕
i=0
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at cn.thread.first.thread.MyThreadStop.run(ThreadStopDome.java:15)
i=1
i=2
i=3
i=4
解说：1.在wait，notify，sleep的线程中使用interrupt会抛异常sleep interrupted。
2.上面也说明了，myThread.interrupt()把线程状态设置为停止，而调用一次Thread.interrupted()后，该状态被清除了。所以后续1，2，3，4顺利打印出来了，也没有抛异常。因为myThread.interrupt()线程停止的状态已经被清除了。

LockSupport

LockSupport类是Java6(JSR166-JUC)引入的一个类，提供了主要的线程同步原语。
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport实际上是调用了Unsafe类里的函数。归结到Unsafe里，仅仅有两个函数：
public native void unpark(Thread jthread);
public native void park(boolean isAbsolute, long time);
参数：isAbsolute參数是指明时间是绝对的，还是相对的。
unpark函数为线程提供“许可(permit)”，线程调用park函数则等待“许可”。
这个有点像信号量，可是这个“许可”是不能叠加的，“许可”是一次性的。
比如：线程B连续调用了三次unpark函数，当线程A调用park函数就使用掉这个“许可”，假设线程A再次调用park，则进入等待状态。
注意。unpark函数能够先于park调用。比方线程B调用unpark函数，给线程A发了一个“许可”，那么当线程A调用park时。它发现已经有“许可”了。那么它会立即再继续执行。

看一段代码：

class ThreadParkService extends Thread {

    private Thread thread;

    public ThreadParkService(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " wakup before");
        LockSupport.unpark(thread);//解锁后线程2立马就可以执行了。
        try {
            System.out.println("解锁后休息三秒哦");
            Thread.sleep(3000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " wakup after");

    }
}

public class ThreadParkDome {

    public static void main(String args[]) {
        Thread thread = Thread.currentThread();

        ThreadParkService service = new ThreadParkService(thread);
        System.out.println(Thread.currentThread().getName()+" start1");
        service.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" center");
        LockSupport.park(thread);
        System.out.println("end");

    }
}

打印结果：
main start1
Thread-0 wakup before
解锁后休息三秒哦
main center
end
Thread-0 wakup after

解说：
主线程main先打印了自己的东西，主线程到了park时被阻塞了。
线程1异步执行打印了 wakup before
main center打印在“解锁后休息3s哦”说明线程1中的unpark先与park执行。
线程1执行了unpark了，这个时候主线程中的park立马被唤醒，开始执行了end。
然后线程1等待了3s后执行了wakup after。

unpark，可以在park之前执行。它们一对一哦。不管什么时候park只要有unpark过一次就好了。

park被阻塞后，unpark执行后park立即被唤醒。与wait与notify不同，notify唤醒wait后，还必须等待notify代码块中的代码执行完毕后wait才能执行。

代码段2:

class ThreadParkService extends Thread {

    private Thread thread;

    public ThreadParkService(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " wakup before");
        LockSupport.unpark(thread);//解锁后线程2立马就可以执行了。
        try {
            System.out.println("解锁后休息三秒哦");
            Thread.sleep(3000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " wakup after");

    }
}

class ThreadParkService2 extends Thread {

    private Thread thread;

    public ThreadParkService2(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + "-线程2开始park before");
        LockSupport.park(this);//阻塞当前执行的线程，不能阻塞其他线程，看源码哦。里面阻塞时并不需要任何传参。
        //LockSupport.park(thread);//这里并不会阻塞thread线程，阻塞的还是当前线程。thread只是做一个标记方便被锁的对象。
        System.out.println(Thread.currentThread().getName() + "-线程2park after");

    }
}


public class ThreadParkDome {


    public static void main(String args[]) {
        Thread thread = Thread.currentThread();

        ThreadParkService2 service2 = new ThreadParkService2(thread);
        System.out.println(Thread.currentThread().getName() + " start2");
        service2.start();

        System.out.println(" 漂亮的分割线---");

        ThreadParkService service = new ThreadParkService(service2);
        System.out.println(Thread.currentThread().getName() + " start1");
        service.start();
    }
}

执行结果：
main start2
漂亮的分割线—
Thread-0-线程2开始park before
main start1
Thread-1 wakup before
解锁后休息三秒哦
Thread-0-线程2park after
Thread-1 wakup after

解说：其实看结果就是线程2阻塞了，线程1唤醒了线程2.就这么简单。
重点来了：
1.park()与park(Object obj)有什么区别？park()是可以不需要参数的哦，就是说加锁时，不需要指定对象。那么它是怎么加锁的呢？点进去看源码

public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);//记录当前线程等待的对象（阻塞对象）；
        UNSAFE.park(false, 0L);//阻塞当前线程；
        setBlocker(t, null);//当前线程等待对象置为null。
}

可以看出来，阻塞的时候UNSAFE.park(false, 0L);根本不需要外面的入参数。
那么setBlocker是用来干吗的呢？它是用来做监控用的，当前被阻塞的对象是那个，可以通过LockSupport中的get之类的方法来获取当前被阻塞的对象。
UNSAFE.park(false, 0L);锁住的是当前正在执行的线程哦。

2.代码中线程2有一个参数，我把主线程传递过去了，想用线程2来阻塞主线程。
main中：
Thread thread = Thread.currentThread();
ThreadParkService2 service2 = new ThreadParkService2(thread);
…
线程2中:
LockSupport.park(thread);
这样是不行的，前面说过park阻塞的是当前正在执行的线程，和外面传递进来的值无关。所以这里被阻塞的还是线程2.
3.unpark需要带上参数，这样才知道解锁那个线程。

LockSupport.park 锁住的是Thread.currentThread()当前线程。

Thread.currentThread()与this

类继承了Thread类后，可以使用this.getName();获取当前线程的名称，但是Thread.currentThread().getName()也获取线程名称。那么它们有什么区别呢？
继承了Thread类后使用this.getName()获取的当前对象的线程名称，而Thread.currentThread().getName()获取的是当前正在运行的线程的名称。
上面代码片段2可以自己执行后测试一下。

park与wait的区别

unpark可以先与park执行，notify不能先与wait执行，不然就不能唤醒了。
unpark需要指定唤醒的线程，而notify是随机唤醒一个wait。
unpark解锁后park立即可以执行，notify解锁后wait需要等待notify所在的synchronized代码块执行完毕后wait才能继续执行。
wait必须在Synchronizer里面才能有效，unpark则不用。
wait是对象锁，park则是线程锁。

HotSpot park实现

synchronized，wait，notify是通过每个对象中的monitor监控器来实现的。
在HotSpot虚拟机的世界里面，每个java线程都有一个Parker的实例，而LockSupper就是通过每个线程里面的Parker实例来实现的。lockSupport底层调用的是UNSAFE.park()，UNSAFE是直接操作操作系统底层的东西，所以没啥好说的。查看这边文章看看了解了解就行。http://www.jianshu.com/p/ceb8870ef2c5

synchronized->每个对象中的monitor（monitorenter，monitorexit）->一系列算法锁优化（偏向锁，自旋锁，轻量级锁）->操作系统函数->cpu指令mutex加锁。
LockSupper->每个线程中的Parker实例->操作系统函数->cpu指令mutex加锁.

linux与windows中调用cpu的指令有所不同，但都是通过cpu的mutex指令来线程互斥的。
synchronized与lockSupport最终都是一把锁。synchronized锁住的是一件房子，也可以锁住一间房间。而lockSupport锁住的是一个柜子，或者一个抽屉柜。它们所的粒度不同而已，但终究是通过操作系统来实现的。

参看

http://www.cnblogs.com/lcchuguo/p/4855664.html
http://www.cnblogs.com/skywang12345/p/3505784.html(深度好文）
http://www.jianshu.com/p/ceb8870ef2c5

piaoslowly

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java多线程高级-线程中断/阻塞（四）

java多线程高级-线程中断/阻塞（四）线程中断／阻塞：interrupt/LockSupport 在Core Java中有这样一句话：”没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断 “。线程中断-interrupt简单定义每个线程都有一个interrupt status标志位，用于表明当前...
复制链接

扫一扫