自定义显示锁工具类（具有超时功能）

接口

package runnable;

import java.util.Collection;

/**
 * @author Livingdd
 * 2019/11/23 16:21
 **/

public interface Lock {

    void lock() throws InterruptedException;

    void lock(long mills)throws InterruptedException,TimeOutException;

    void unLock();

    Collection<Thread> getCurrentBlockThreads();

    int getCurrentBlockThreadCount();

    class TimeOutException extends Exception{
        public TimeOutException(String message){
            super(message);
        }
    }
}

工具类

package runnable;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;

/**
 * @author Livingdd
 * 2019/11/23 16:28
 * 自定义显示锁工具类
 **/
public class BooleanLock implements Lock{

    private boolean isLock;

    private Collection<Thread> blockThreadCollection= new ArrayList<>();

    private Thread currentThread;
    public BooleanLock(){
        this.isLock = false;
    }
    @Override
    public synchronized void lock() throws InterruptedException {
        Optional.of(Thread.currentThread().getName()+"is executor lock")
                .ifPresent(System.out::println);
        while (this.isLock){
            blockThreadCollection.add(Thread.currentThread());
            this.wait();
        }
        this.isLock = true;
        this.currentThread = Thread.currentThread();
        blockThreadCollection.remove(Thread.currentThread());

    }

    @Override
    public synchronized void lock(long mills) throws InterruptedException, TimeOutException {
        long endTime = mills + System.currentTimeMillis();
        long hasRem = mills;
        while (this.isLock){
            if(hasRem <= 0)
                throw new TimeOutException("Time Out");
            blockThreadCollection.add(Thread.currentThread());
            this.wait(mills);
            hasRem = endTime - System.currentTimeMillis();
        }
        this.isLock = true;
        this.currentThread = Thread.currentThread();
        blockThreadCollection.remove(Thread.currentThread());
    }

    @Override
    public synchronized void unLock() {
        if(Thread.currentThread() == this.currentThread){
            this.isLock = false;
            Optional.of(Thread.currentThread().getName()+"is unLock")
                    .ifPresent(System.out::println);
            this.notifyAll();
        }
    }

    @Override
    public Collection<Thread> getCurrentBlockThreads() {
        return Collections.unmodifiableCollection(this.blockThreadCollection);
    }

    @Override
    public int getCurrentBlockThreadCount() {
        return this.blockThreadCollection.size();
    }

}

测试类

package runnable;


import java.util.Optional;
import java.util.stream.Stream;

/**
 * @author Livingdd
 * 2019/11/18 21:22
 **/
public class ThreadTest {
    public static void main(String[] args) {
        String[] str = new String[4];
        for (int i = 0; i < str.length; i++) {
            str[i] = "T"+String.valueOf(i);
        }
        final BooleanLock booleanLock = new BooleanLock();
        Stream.of(str).forEach(name->{
            new Thread(()->{
                try {
                    booleanLock.lock(1_000);
                    work();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch (Lock.TimeOutException e) {
                    Optional.of(Thread.currentThread().getName()+" is time out")
                            .ifPresent(System.out::println);
                }finally {
                    booleanLock.unLock();
                }
            },name).start();
        });
        booleanLock.unLock();
    }

    public static void work(){
        Optional.of(Thread.currentThread().getName()+" is working")
                .ifPresent(System.out::println);
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}