JUC中condition的使用、以及LockSupport工具类的使用

最新推荐文章于 2024-04-04 00:49:03 发布

cully#

最新推荐文章于 2024-04-04 00:49:03 发布

阅读量129

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/qq_42858175/article/details/106450064

版权

多线程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Object的wait和notify/notify是与对象监视器配合完成线程间的等待/通知机制**，而Condition与Lock配合完成等待通知机制**，前者是java底层级别的，后者是语言级别的，具有更高的可控制性和扩展性。

使用规则：

Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁，之后调用Condition接口的await()将释放锁，并且在该Condition上等待，直到有其他线程调用Condition的signal()方法唤醒线程，使用方式和wait()、notify()类似。

  static ReentrantLock reentrantLock = new ReentrantLock();
    //Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁
    static Condition condition = reentrantLock.newCondition();

常用API
1、void await() throws InterruptedException:当前线程进入等待状态，如果其他线程调用condition的signal或者signalAll方法并且当前线程获取Lock从await方法返回，如果在等待状态中被中断会抛出被中断异常；
2、long awaitNanos(long nanosTimeout)：当前线程进入等待状态直到被通知，中断或者超时；
3、boolean await(long time, TimeUnit unit) throws InterruptedException：同第二种，支持自定义时间单位，false：表示方法超时之后自动返回的，true：表示等待还未超时时，await方法就返回了（超时之前，被其他线程唤醒了）
4、boolean awaitUntil(Date deadline) throws InterruptedException：当前线程进入等待状态直到被通知，中断或者到了某个时间
5、void awaitUninterruptibly();：当前线程进入等待状态，不会响应线程中断操作，只能通过唤醒的方式让线程继续

代码举例

package com.example.demo.demo.conditionLockDemo;

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

/**
 * JUC(java.util.concurrent.)中的Condition对象实现线程等待和唤醒等待中的线程
 */
public class ConditionLockTest {
    static ReentrantLock reentrantLock = new ReentrantLock(false);
    //Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁
    static Condition condition = reentrantLock.newCondition();

    public static class T1 extends Thread {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁...");
            reentrantLock.lock();
            try {
                System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取到了锁...");
                condition.await();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();//一定要在finally里写解锁,防止线程阻塞后一直无法释放锁
            }
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放了锁...");
        }
    }

    public static class T2 extends Thread {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁...");
            reentrantLock.lock();
            try {
                System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取到了锁...");
                condition.signal();//当前线程等待被唤醒
                System.out.println("signal...");
                TimeUnit.SECONDS.sleep(5);//当前线程暂停,回到主线程,但是因为在同步方法里等待的，所以并不会释放锁给别的线程
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();//一定要在finally里写解锁,防止线程阻塞后一直无法释放锁
            }
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放了锁...");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        T2 t2 = new T2();
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        System.out.println("开始前");
        System.out.println("主线程线程暂停,时间分配给别的线程，只有t1start了，执行t1");
        TimeUnit.SECONDS.sleep(1);//主线程线程暂停,时间分配给别的线程
        t2.start();
        System.out.println("t2启动了，但是主线程没有暂停或者，所以继续等待主线程结束或者暂停才能启动t2");
        System.out.println("主线程线程暂停,时间分配给别的线程，只有t2start了，执行t2");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("在线程2中自己暂停了回到主线程");

    }

}

执行结果

开始前
主线程线程暂停,时间分配给别的线程，只有t1start了，执行t1
1590856469216,t1准备获取锁...
1590856469216,t1获取到了锁...
t2启动了，但是主线程没有暂停或者，所以继续等待主线程结束或者暂停才能启动t2
主线程线程暂停,时间分配给别的线程，只有t2start了，执行t2
1590856470216,t2准备获取锁...
1590856470216,t2获取到了锁...
signal...
在线程2中自己暂停了回到主线程
1590856475216,t2释放了锁...
1590856475216,t1释放了锁...

await(long time, TimeUnit unit)超时

package com.example.demo.demo.conditionLockDemo;


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

public class AwaitDemo {
    static ReentrantLock reentrantLock = new ReentrantLock();
    //Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁
    static Condition condition = reentrantLock.newCondition();

    public static class T1 extends Thread {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "准备获取锁...");
            reentrantLock.lock();
            try {
                System.out.println(System.currentTimeMillis() + "," + this.getName() + "获取到了锁...");
                boolean b = condition.await(5, TimeUnit.SECONDS);//当前线程等待被唤醒
                System.out.println(b);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();//一定要在finally里写解锁,防止线程阻塞后一直无法释放锁
            }
            System.out.println(System.currentTimeMillis() + "," + this.getName() + "释放了锁...");
        }
    }

   
    public static void main(String[] args) throws InterruptedException {
       T1 t1 = new T1();
       t1.setName("t1");
       t1.start();
       System.out.println("主线程结束");
       TimeUnit.SECONDS.sleep(1);
       reentrantLock.lock();
       try {
           condition.signal();//必须放在lock的锁中
       }
       finally {
           reentrantLock.unlock();
       }
    }
}

结果

主线程结束
1590856706938,t1准备获取锁...
1590856706938,t1获取到了锁...
true
1590856707938,t1释放了锁...

关于Object和Condtion中线程等待和唤醒的局限性，有以下几点：

1、线程等待和唤醒的方法能够执行的先决条件是：线程需要先获取锁
2、唤醒方法需要在等待方法之后调用，线程才能够被唤醒
关于这2点，LockSupport都不需要，就能实现线程的等待和唤醒

LockSupport工具类的使用

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过**park()和unpark(thread)**方法来实现阻塞和唤醒线程的操作的

LockSupport中常用的方法

void park()：阻塞当前线程，如果调用unpark方法或者当前线程被中断，从能从park()方法中返回
void park(Object blocker)：功能同方法1，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，增加了超时返回的特性
void parkNanos(Object blocker, long nanos)：功能同方法3，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
void parkUntil(long deadline)：阻塞当前线程，直到deadline，deadline是一个绝对时间，表示某个时间的毫秒格式
void parkUntil(Object blocker, long deadline)：功能同方法5，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查；
代码示例

package com.example.demo.demo.conditionLockDemo;

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

public class LockSupportDemo {
    public static class T1 extends Thread{

        @Override
        public void run() {
            System.out.println("开始t1");
            LockSupport.park();//线程开始等待
            System.out.println("唤醒了");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        t1.setName("t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        LockSupport.unpark(t1);
        System.out.println("开始唤醒");
    }
}

在这里插入图片描述
线程的等待与唤醒没有放在同步方法里面。正常运行结束

如果将主方法中的等待TimeUnit.SECONDS.sleep(1)去掉
结果
在这里插入图片描述
先执行了唤醒再执行等待，程序正常结束

park()让线程等待之后，是否能够响应线程中断

package com.example.demo.demo.conditionLockDemo;

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

public class LockSupportDemo {
    public static class T1 extends Thread{

        @Override
        public void run() {
            System.out.println("开始t1");
            System.out.println(Thread.currentThread().getName()+"中断前:"+Thread.currentThread().isInterrupted());
            LockSupport.park();//线程开始等待
            System.out.println(Thread.currentThread().getName()+"中断后:"+Thread.currentThread().isInterrupted());
            System.out.println("唤醒了");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        t1.setName("t1");
        t1.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("11");
//        LockSupport.unpark(t1);
        t1.interrupt();//线程中断

//        System.out.println("开始唤醒");
    }
}

结果
在这里插入图片描述
中断没有执行唤醒方法unpark(),线程t1依然被唤醒
结论：LockSupport.park方法让线程等待之后，唤醒方式有2种：

调用LockSupport.unpark方法
调用等待线程的 interrupt()方法，给等待的线程发送中断信号，可以唤醒线程

线程等待和唤醒的3种方式做个对比

方式1：Object中的wait、notify、notifyAll方法
方式2：juc中Condition接口提供的await、signal、signalAll方法
方式3：juc中的LockSupport提供的park、unpark方法

cully#

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC中condition的使用、以及LockSupport工具类的使用

Object的wait和notify/notify是与对象监视器配合完成线程间的等待/通知机制**，而Condition与Lock配合完成等待通知机制**，前者是java底层级别的，后者是语言级别的，具有更高的可控制性和扩展性。使用规则：Condition由ReentrantLock对象创建，并且可以同时创建多个，Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁，之后调用Condition接口的await()将释放锁，并且在该Condition上等待，直到有其他
复制链接

扫一扫