自定义显式锁BooleanLock

一时失言乱红尘 2023-01-07 12:26 150阅读 0赞

今天看到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);
        }
    }