自定义显式锁BooleanLock-蒲公英云

自定义显式锁BooleanLock

今天看到Java高并发编程详解一书中的自定义显式锁代码不错，写下来以便日后查阅

public interface Lock { 
    void lock() throws InterruptedException;
    void lock(long mills) throws InterruptedException, TimeoutException;
    void unlock();
    List<Thread> getBooleanThreads();
}
package com.thread.test.booleanlock;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeoutException;
import static java.lang.Thread.currentThread;
public class BooleanLock implements Lock { 
    //当前线程
    private Thread currentThread;
    //锁是否被占用
    private boolean locked = false;
    //阻塞线程集合
    private final List<Thread> blockedList = new ArrayList<>();
    @Override
    public void lock() throws InterruptedException { 
        synchronized (this) { 
            while (locked) { 
                //暂存当前线程
                final Thread tempThread = currentThread();
                try { 
                    if (!blockedList.contains(currentThread())) { 
                        blockedList.add(currentThread());
                    }
                    this.wait();
                } catch (InterruptedException e) { 
                    //如果当前线程被中断，则将当前线程从list中移除，避免内存泄露
                    blockedList.remove(tempThread);
                    //继续抛出中断异常
                    throw e;
                }
            }
            blockedList.remove(currentThread());
            this.locked = true;
            this.currentThread = currentThread();
        }
    }
    @Override
    public void lock(long mills) throws InterruptedException, TimeoutException { 
        synchronized (this) { 
            if (mills < 0) { 
                //可抛异常亦可执行lock()方法，这里执行lock()方法
                this.lock();
            } else { 
                long remainingMills = mills;
                long endMills = System.currentTimeMillis() + remainingMills;
                while (locked) { 
                    if (remainingMills <= 0) { 
                        throw new TimeoutException("cant get the lock during " + mills + " ms.");
                    }
                    if (!blockedList.contains(currentThread())) { 
                        blockedList.add(currentThread());
                    }
                    this.wait(mills);
                    remainingMills = endMills - System.currentTimeMillis();
                }
                blockedList.remove(currentThread());
                this.locked = true;
                this.currentThread = currentThread();
            }
        }
    }
    @Override
    public void unlock() { 
        synchronized (this) { 
            if (currentThread == currentThread()) { 
                this.locked = false;
                Optional.of(currentThread().getName() + " release the lock.").ifPresent(System.out::print);
                this.notifyAll();
            }
        }
    }
    @Override
    public List<Thread> getBooleanThreads() { 
        return Collections.unmodifiableList(blockedList);
    }
}