自定义Lock锁

最新推荐文章于 2024-03-17 13:26:41 发布

不会敲helloworld

最新推荐文章于 2024-03-17 13:26:41 发布

阅读量230

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/ncpz123/article/details/120071950

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文介绍了如何实现一个自定义的Java Lock锁，使用AtomicReference和LinkedBlockingQueue管理线程的获取与释放。在lock()方法中，通过CAS操作尝试获取锁，并在未成功时将线程放入等待队列。unlock()方法则检查当前线程是否为锁的所有者并解锁，同时唤醒等待队列中的其他线程。通过一个模拟高并发场景的测试程序，展示了锁的使用以确保共享变量的安全操作。

摘要由CSDN通过智能技术生成

步骤：

写一个类实现Lock接口
实现Lock方法
实现unLock方法

自定义Lock锁代码：

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

/**
 * Created by Martin on 2021/9/2 22:44
 *
 * 手写lock锁
 */
public class TestLock implements Lock {
    //登记我们的线程
    AtomicReference<Thread> owner=new AtomicReference<Thread>();

    //队列--存放那些没有抢到锁的线程（线程安全+高效）  delayqueue---限时订单
    LinkedBlockingQueue waiters=new LinkedBlockingQueue();

    @Override
    public void lock() {
        while (!owner.compareAndSet(null,Thread.currentThread())){ //用cas确保线程安全
            //false,如果抢不到了
            waiters.add(Thread.currentThread());
            LockSupport.park(); //让当前的线程阻塞
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        //只有持有锁的线程才能解锁
        if (owner.compareAndSet(Thread.currentThread(),null)){
            //唤醒其它等待的线程
            for(Object object: waiters.toArray()){
                Thread next=(Thread) object;
                LockSupport.unpark(next);
                //清除队列里面的线程
                waiters.remove(Thread.currentThread());
            }
        }
    }
    @Override
    public Condition newCondition() {
        return null;
    }
}

主程序测试代码

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by Martin on 2021/9/2 19:44
 *
 * 多线程操作共享变量--原之类操作
 */
public class handDemo {
   int i= 60000;  //共享变量
    TestLock testLock = new TestLock();
    //多个线程同时跑order方法
    public void order(){
      testLock.lock();
      try {
          i--;  //i--操作
      } finally {
          testLock.unlock();
      }
    }

    //模拟高并发场景
    public static void main(String[] args) throws InterruptedException {
        handDemo handDemo = new handDemo();
        for(int j=0;j<6;j++){
            new Thread(
                    ()->{
                        for (int k=0;k<10000;k++){
                            handDemo.order();
                        }
                    }
            ).start();
        }
        Thread.sleep(3000);
        System.out.println(handDemo.i);
    }
}