22_LockSupport

是什么

官方解释:LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

一句话:LockSupport中的park()和unpark()的作用分别是阻塞线程解除阻塞线程


怎么玩

线程等待唤醒机制(wait/notify)

3种让线程等待和唤醒的方法
方式1: 使用synchronized

使用Object中的wait()方法让线程等待, 使用Object中的notify()方法唤醒线程

正常情况:

package com.aqs.locksupport;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {

    static Object objectLock = new Object();

    private static void synchronizedWaitNotify() {
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            }
        }, "A").start();
        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            }
        }, "B").start();
    }

    public static void main(String[] args) {
        SynchronizedDemo.synchronizedWaitNotify();
    }
}

在这里插入图片描述


异常情况1:wait方法和notify方法,两个都去掉同步代码块

package com.aqs.locksupport;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {

    static Object objectLock = new Object();

    private static void synchronizedWaitNotify() {
        new Thread(() -> {
//            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
//            }
        }, "A").start();
        new Thread(() -> {
//            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
//            }
        }, "B").start();
    }

    public static void main(String[] args) {
        SynchronizedDemo.synchronizedWaitNotify();
    }
}

在这里插入图片描述

抛出异常!

原因:synchronized是关键字属于JVM层面。monitorenter(底层是通过monitor对象来完成,其实wait/notify等方法也依赖monitor对象只能在同步块或方法中才能调用wait/notify等方法)


异常情况2:将notify放在wait方法前面

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {
    static Object objectLock = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            }
        }, "A").start();
        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            }
        }, "B").start();
    }
}

在这里插入图片描述

B线程先notify后,A线程后使用wait会出现另一个线程一直处于等待状态


小总结

  • wait和notify方法必须要在同步块或者方法里面且成对出现使用
  • 先wait后notify才OK

方式2:使用 lock

Condition接口中的awaitsignal方法实现线程的等待和唤醒

正常情况:

package com.aqs.locksupport;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

    static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    //等待
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
                lock.unlock();
            }
        }, "A").start();

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            } finally {
                //唤醒
                lock.unlock();
            }
        }, "B").start();
    }
}

在这里插入图片描述


异常情况1:不进行lock加锁、放锁

package com.aqs.locksupport;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

    static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        new Thread(() -> {
//            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
//                lock.unlock();
            }
        }, "A").start();

        new Thread(() -> {
//            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            } finally {
//                lock.unlock();
            }
        }, "B").start();
    }

}

在这里插入图片描述

同样也抛出异常!


异常情况2:先unlock释放锁,再lock加锁

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

    static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    //TODO 一直卡在这里等待被唤醒
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
                lock.unlock();
            }
        }, "A").start();

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            } finally {
                lock.unlock();
            }
        }, "B").start();
    }
}

在这里插入图片描述

B线程先进行释放锁,A线程再加锁,线程一直处于等待状态!


总结

传统的synchronized和Lock实现等待唤醒通知的约束

必须满足下列条件:

  • 线程先要获得并持有锁,必须在锁块(synchronized或lock)中
  • 必须要先等待后唤醒,线程才能够被唤醒

方式3:使用LockSupport

LockSupport类中的park等待和unpark唤醒

是什么

通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作

官网解释:LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport类使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能,每个线程都有一个许可(permit),permit只有两个值1和零,默认是零。可以把许可看成是一种(0,1)信号量(Semaphore),但与Semaphore不同的是,许可的累加上限是1。


主要方法

阻塞:park()/park(Object blocker):阻塞当前线程/阻塞传入的具体线程

permit默认是0,所以一开始调用park()方法,当前线程就会阻塞,直到别的线程将当前线程的permit设置为1时,park方法会被唤醒,然后会将permit再次设置为0并返回。

唤醒:unpark(Thread thread):唤醒处于阻断状态的指定线程

调用unpark(thread)方法后,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,permit值还是1)会自动唤醒thread线程,即之前阻塞中的LockSupport.park()方法会立即返回。


代码

正常情况:无锁块要求

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * LockSupport:俗称 锁中断
 * 以前的两种方式:
 * 		1.以前的等待唤醒通知机制必须synchronized里面有一个wait和notify
 * 		2.lock里面有await和signal
 * 这上面这两个都必须要持有锁才能干
 * LockSupport它的解决的痛点
 * 		1.LockSupport不用持有锁块,不用加锁,程序性能好,
 * 		2.先后顺序,不容易导致卡死
 */
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "come  in....");
            LockSupport.park();//阻塞当前线程...等待被放行
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
        }, "t1");

        t1.start();

        //等待3s,让t2线程发放许可证
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            LockSupport.unpark(t1);

        }, "t2").start();
    }
}

在这里插入图片描述


之前错误的先唤醒后等待,LockSupport照样支持:

public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t ----" + "come  in...." + System.currentTimeMillis());
            LockSupport.park();//阻塞当前线程...等待被放行
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒...." + System.currentTimeMillis());
        }, "t1");

        t1.start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            LockSupport.unpark(t1);

        }, "t2").start();
    }
}

在这里插入图片描述

发现t1线程并没有进入执行lock方法(此时它已有许可证)


底层原理

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语,LockSupport是一个线程阻塞工具类,所有的方法都是静态方法,可以让线程在任意位置阻塞,阻塞之后也有对应的唤醒方法。归根结底,LockSupport调用的Unsafe中的native代码

public static void park() {
    UNSAFE.park(false, 0L);
}

public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

LockSupport提供park()和unpark()方法实现阻塞线程解除线程阻塞的过程:

  • LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1,0的开关,默认是0。
  • 调用一次unpark就加1变成1,调用一次park会消费permit,也就是将1变成0,同时park立即返回。
  • 如再次调用park会变成阻塞(因为permit为零了会阻塞在这里,一直到permit变为1),这时调用unpark会把permit置为1。
  • 每个线程都有一个相关的permit, permit最多只有一个,重复调用unpark也不会积累凭证。

形象的理解:

  • 线程阻塞需要消耗凭证(permit),这个凭证最多只有1个。
  • 当调用park方法时 ,如果有凭证,则会直接消耗掉这个凭证然后正常退出; 如果无凭证,就必须阻塞等待凭证可用;
  • 而unpark则相反,它会增加一个凭证,但凭证最多只能有1个,累加无效。
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "come  in....");
            //消耗一张凭证
            LockSupport.park();
            //TODO 没有凭证,继续等待.....
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
        }, "t1");

        t1.start();

       try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            //TODO 发放凭证:最多为1
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            
        }, "t2").start();
    }
}

在这里插入图片描述

此时虽然unpark了两次,但是permit许可证最多为1,所以第一次park消费掉凭证,第二次park时,许可证为0,阻塞等待。


# 面试题
# 为什么可以先唤醒线程后阻塞线程?
因为unpark获得了一个凭证,之后再调用park方法,就可以名正言顺的凭证消费,故不会阻塞。

# 为什么唤醒两次后阻塞两次,但最终结果还会阻塞线程?
因为凭证的数量最多为1,连续调用两次unpark和调用一次unpark效果一样,只会增加一个凭证;而调用两次park却需要消费两个凭证,证不够,不能放行。

  • 1
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值