java并发原理实战(9)--手动实现一个可重入锁

置顶怒放de生命2010

已于 2022-04-08 20:51:46 修改

阅读量315

点赞数

CC 4.0 BY-SA版权

分类专栏：并发编程文章标签：多线程并发编程

于 2020-01-27 20:45:04 首次发布

本文链接：https://blog.csdn.net/baidu_21349635/article/details/104095406

并发编程专栏收录该内容

25 篇文章

订阅专栏

本文详细介绍了如何自定义实现一个线程锁，包括其核心方法lock和unlock的同步控制，通过实例验证了线程安全性和锁的可重入特性。

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

自定义个锁

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

public class MyLock implements Lock {

    private boolean islock = false;
    Thread lockBy = null;
    int lockCount = 0;
    @Override
    public synchronized void lock() {
        Thread currentThread = Thread.currentThread();
        while (islock && lockBy != currentThread){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lockBy = Thread.currentThread();
        islock = true;
        lockCount++;

    }
    @Override
    public synchronized void unlock() {
        if (lockBy == Thread.currentThread()){
            lockCount--;
           if (lockCount == 0){
               islock = false;
               notify();
           }
        }

    }

    @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;
    }
}

测试：线程安全

public class Sequence {
    private  int value;
    MyLock lock = new MyLock();

    public  int getNext() {
        lock.lock();
        value++;
        lock.unlock();
        return value;
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence();

        new Thread(() -> {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " " + sequence.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        ).start();
        new Thread( () -> {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " " + sequence.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        ).start();
        new Thread( () -> {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " " + sequence.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        ).start();
    }

}

运行结果:
在这里插入图片描述
结果显示：线程安全

测试：是否可重入

public class Demo {
    MyLock lock = new MyLock();


    public synchronized void a() {

        lock.lock();
        System.out.println("a");
        b();
        lock.unlock();
    }

    public synchronized void b() {
        lock.lock();
        System.out.println("b");
        lock.unlock();
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        new Thread(()-> {
            d.a();
        }).start();

    }
}