使用synchronized实现ReentrantLock(美团面试题)

使用synchronized实现ReentrantLock

前提知识：

获取锁：

1. 如果当前线程和已经获取锁的线程是一样的，不用获得。
2. 如果当前锁不为空，已经被别人持有了，则进入等待队列。
3. 如果锁为空，且获取到锁，则把自己标志为上锁。

释放锁：

1. 如果当前线程和获取锁线程不一致不能释放。
2. 如果释放后我们需要唤醒等待队列。

代码实现：

package com.yang.leetcode.other;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class SynchronizedToReentrantLock {
    // 设置锁为空的标志
    private final static long NONE = -1;
    // 设置当前获取锁的线程
    private long owner = NONE;
    // 执行上锁lock
    public synchronized void lock(){
        long currentThreadId = Thread.currentThread().getId();
        // 如果当前线程和锁持有者一样，不用上锁
        if(this.owner == currentThreadId){
            throw new IllegalStateException("lock has been a acquired by current thread");
        }
        // 如果不一样我们直到锁没被线程持
        while(this.owner!=NONE){
            System.out.println(String.format("thread %s is waiting lock ", currentThreadId));
            try {
                // 让线程进入等待
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 等待结束，获取锁
        this.owner = currentThreadId;
        System.out.println(String.format("lock is acquired by thread %s", currentThreadId));
    }
    // 执行释放锁
    public synchronized void unlock(){
        // 如果当前锁不是自己不允许卸载
        long currentThreadId = Thread.currentThread().getId();
        // 如果当前线程和锁持有者一样，不用上锁
        if(this.owner != currentThreadId){
            throw new IllegalStateException("only lock owner can unlock this lock");
        }
        // 卸载锁，并且唤醒等待队列
        System.out.println(String.format("thread %s is unlocking", owner));
        owner = NONE;
        notify();
    }
    // 测试

    public static void main(String[] args) {
        final SynchronizedToReentrantLock lock = new SynchronizedToReentrantLock();
        ExecutorService executor = Executors.newFixedThreadPool(20, new ThreadFactory() {
            private ThreadGroup group = new ThreadGroup("test thread group");
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(group,r);
            }
        });
        for (int i = 0; i < 20; i++) {
            executor.submit(()->{
                lock.lock();
                System.out.println(String.format("thread %s is running...", Thread.currentThread().getId()));
                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.unlock();
            });
        }

    }
}