欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

自定义TryLock 显式锁【仅供参考】

程序员文章站 2023-11-13 23:40:04
import java.util.concurrent.atomic.AtomicBoolean;public class TryLock { /** * 在 TryLock 的内部,我们借助于 AtomicBoolean 的布尔原子性操作方法 */ private final AtomicBoolean ab = new AtomicBoolean(false); /** * 线程保险箱,用于存放与线程上下文关联的数据副本 */ ....
import java.util.concurrent.atomic.AtomicBoolean;

public class TryLock {
    /**
     *  在 TryLock 的内部,我们借助于 AtomicBoolean 的布尔原子性操作方法
     */
    private final AtomicBoolean ab = new AtomicBoolean(false);
    /**
     * 线程保险箱,用于存放与线程上下文关联的数据副本
     */
    private final ThreadLocal<Boolean> threadLocal = ThreadLocal.withInitial(()-> false);

    /**
     * 可立即返回的 lock 方法
     */
    public boolean tryLock(){
        /**
         * 借助于 AtomicBoolean  的 CAS 操作对布尔值进行修改
         */
        boolean result = ab.compareAndSet(false,true);
        if(result){
            /**
             *  当修改成功的时候,同步更新 threadLocal 的数据副本值
             */
            threadLocal.set(result);
        }
        return result;
    }
    /**
     * 锁的释放
     */
    public boolean release(){
        /**
         *  判断调用 release 方法的线程是否成功获得了该锁
         */
        if(threadLocal.get()){
            /**
             * 标记锁被释放,并且原子性地修改布尔值为 false
             */
            threadLocal.set(false);
            /**
             * 下面的方法对 ab 当前的布尔值进行 CAS 操作,当预期值与 ab 当前值一致的时候操作才能成功,
             * 否则操作将直接失败,因此执行该方法的线程不会进入阻塞,这一点是非常关键的。
             */
            return ab.compareAndSet(true,false);
        }else{
            return false;
        }
    }
}

--------------------测试代码

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import static java.lang.Thread.currentThread;

public class TryLockExample {
    private final static Object  VAL_OBJ = new Object();

    public static void main(String[] args) {
        /**
         * 定义 TryLock 锁
         */
        final TryLock lock = new TryLock();
        final List<Object> validation = new ArrayList<Object>();
        /**
         * 启动 10 个线程,并且不断地进行锁的获取和释放操作
         */
        for(int i = 0 ; i < 10 ; i++){
            new Thread(new Runnable() {
                public void run() {
                    try{
                        while(true){
                            /**
                             * 尝试获取该锁,该方法不会导致当前线程进入阻塞
                             *
                             * currentThread(): Returns a reference to the currently executing thread object.
                             */
                            if(lock.tryLock()){
                                System.out.println(currentThread() + ":get  the lock");
                                if( validation.size() > 1){
                                    throw new IllegalStateException("validation failed.");
                                }
                                validation.add(VAL_OBJ);
                                TimeUnit.MILLISECONDS.sleep(2);
                            }else{
                                System.out.println(currentThread() + ": not get the lock");
                                // 未获得锁,简单做个休眠,以防止出现 CPU 过高电脑死机的情况发生
                                TimeUnit.MILLISECONDS.sleep(2);
                            }
                        }
                    }catch(InterruptedException e ){
                        e.printStackTrace();
                    }finally {
                        // 在  finally 语句块中进行锁的释放操作
                        if(lock.release()){
                            System.out.println(currentThread() + ": release the lock.");
                            validation.remove(VAL_OBJ);
                        }
                    }
                }
            }).start();
        }
    }

}

本文地址:https://blog.csdn.net/lierming__/article/details/112103375

相关标签: 多线程