实现Look接口，自定义锁简单实现（不可重入、可重入）

最新推荐文章于 2025-01-27 13:46:16 发布

qq_41911762

最新推荐文章于 2025-01-27 13:46:16 发布

阅读量561

点赞数

分类专栏： Java并发编程文章标签： JUC Lock 可重入

本文链接：https://blog.youkuaiyun.com/qq_41911762/article/details/102808972

版权

Java并发编程专栏收录该内容

12 篇文章

订阅专栏

本文介绍了如何实现Lock接口，分别展示了不可重入和可重入的锁的简单实现。在不可重入的例子中，当主线程尝试在已持有的锁上再次加锁时，它会进入等待状态，而非造成死锁。而在可重入的实现中，允许同一个线程多次获取同一锁，确保了方法的递归调用能够正常执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、简单实现（不可重入）

Lock的实现类：

package mylock;

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

public class MyLock implements Lock {
    boolean isHeld = false;//当前锁有没有被线程持有

    @Override
    public synchronized void lock() {
        if (isHeld) {//如果被线程持有，则当前线程等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isHeld = true;//被被线程持有，则当前线程获取到锁
    }

    @Override
    public synchronized void unlock() {
        notify();//随机唤醒一个等待的线程
        isHeld=false;//没有被持有
    }

    @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 Condition newCondition() {
        return null;
    }
}

测试类：

package mylock;

public class Test {
    static MyLock myLock=new MyLock();
    static int count = 0;

    public static void increase() {
        myLock.lock();
        count++;
        myLock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    increase();
                }
            }
            ).start();
        }
        Thread.sleep(1000);
        System.out.println(count);//1000
    }
}

验证不可重入：

package mylock;

public class Test2 {
    static MyLock lock=new MyLock();
    void method1(){
        lock.lock();
        System.out.println("进入方法1");
        method2();
        lock.unlock();
    }
    void  method2(){
        lock.lock();
        System.out.println("进入方法2");
        lock.unlock();
    }

    public static void main(String[]a){
        Test2 demo=new Test2();
        demo.method1();
    }
}
/*
    输出：
    进入方法1
 */

主线程进执行method1时，还没有线程获取锁，在lock()方法中主线程将isHeld改为true。当执行method2时，主线程执行到lock()方法，这时isHeld已经为true，所以经被持有，也就是被自己持有，所以进行等待(不是死锁)。

2、可重入的实现

package mylock;

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

public class MyLock implements Lock {
    private boolean isHeld = false;//当前锁有没有被线程持有
    private Thread holdLockThread = null;//记录持有锁的线程
    private int reentryCount = 0;//记录重入次数

    @Override
    public synchronized void lock() {
        if (isHeld && Thread.currentThread() != holdLockThread) {//如果锁被线程持有，并且当前线程不是持有锁的线程，则当前线程等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isHeld = true;//被被线程持有，则当前线程获取到锁
        holdLockThread = Thread.currentThread();//持有锁的线程为当前线程
        reentryCount++;//重入次数加1
    }

    @Override
    public synchronized void unlock() {
        if (Thread.currentThread() == holdLockThread) {//如果当前线程是持有锁的线程
            reentryCount--;//重入次数减1
            if (reentryCount == 0) {//如果重入次数为0了，就该释放锁了
                notify();//随机唤醒一个等待的线程
                isHeld = false;//没有被持有
            }
        }
    }

    @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 Condition newCondition() {
        return null;
    }
}

验证方式和上面一样，这下就能在method1中进入method2了。