currentHashMap的公平锁，可中断响应，限制等待实例-阿里云开发者社区

currentHashMap的公平锁，可中断响应，限制等待实例

2022-09-26 126

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： currentHashMap的公平锁，可中断响应，限制等待实例

HashMap是线程非安全的，怎么能线程安全呢，这时候hashtable就出现了，hashmap允许放null，且有且只有一个null，因为不能key不能重复，hashtable不允许放null。

Hashtable的源码里都上了synchronized锁，导致效率低。

这时候这篇文章的主角currentHashmap就出现了。

currentHashmap1.7之前都是实现Reentrantlock，并不是整个代码都上锁，而是需要线程安全的地方上锁，这样运行效率远远高于hashtable，他把内部分成许多segment，然后分别给需要上锁的地方上锁。

说到synchronized和Reentrantlock，就可以来聊一下他们两个的区别？

他们都是io阻塞锁，线程运行的时候，如果被另一个线程加锁，需要等另一个线程运行完，才能运行。

Synchronized会自己自动释放锁，Reentrantlock则需要自己手动释放锁，而且手动释放锁必须放在finally里面unlock，建议新手用前者。

Reentrantlock是可以公平，可以中断响应，限制等待时间。

1、Lock()会一直等待锁获取到，可以设置公平锁。

公平锁指当锁可用时，会让等待时间最长的线程获取锁。非公平锁指随便分配线程获取锁。

2、LockInterruptibly()可以也会等待获取，但可以自行中断。

3、Trylock方法判断当前线程是否能获取到锁，获取到返回true，没有获取到返回false，还可以设定过期时间。

场景一公平锁的实现：

/**
     * 公平锁
     *
     * @param args
     */
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new TestThread(i));
            thread.start();
        }
    }
    static class TestThread implements Runnable {
        Integer z;
        public TestThread(Integer i) {
            this.z = i;
        }
        @Override
        public void run() {
            try{
                Thread.sleep(1000);
            }catch (Exception e){
            }
            for (int i = 0; i < 2; i++) {
                System.out.println(Thread.currentThread().getName()+"==="+z);
            }
        }
    }

公平锁的结果，为了更好地获取信息，让线程休息1s，可以看到公平锁几乎都是轮流获取：

非公平锁的，线程则会重复获取锁：

场景二:

/**
     * 中断响应实例
     */
    public static void main(String[] args) {
        ReentrantLock lock1 = new ReentrantLock();
        Thread thread1 = new Thread(new TestThread(lock1));
        Thread thread2 = new Thread(new TestThread2(lock1));
        thread1.start();
        thread2.start();
        //中断线程
        thread2.interrupt();
    }
    static class TestThread implements Runnable {
        Lock firstName;
        public TestThread(Lock firstName) {
            this.firstName = firstName;
        }
        @Override
        public void run() {
            try {
                System.out.println("进入" + Thread.currentThread().getName());
                firstName.lockInterruptibly();
                Thread.sleep(5000);
            } catch (Exception e) {
            } finally {
                firstName.unlock();
                System.out.println(Thread.currentThread().getName() + "结束！！");
            }
        }
    }
    static class TestThread2 implements Runnable {
        Lock firstName;
        public TestThread2(Lock firstName) {
            this.firstName = firstName;
        }
        @Override
        public void run() {
            try {
                System.out.println("进入" + Thread.currentThread().getName());
                firstName.lockInterruptibly();
                Thread.sleep(5000);
            } catch (Exception e) {
            } finally {
                firstName.unlock();
                System.out.println(Thread.currentThread().getName() + "结束！！");
            }
        }
    }

线程中断之后，则就不会一直等待。

场景三：

/**
     * 限制时间trylock
     */
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        Thread thread0 = new Thread(new TestThread0(reentrantLock));
        thread0.start();
        Thread thread1 = new Thread(new TestThread1(reentrantLock));
        thread1.start();
    }
}
class TestThread0 implements Runnable {
    ReentrantLock reentrantLock;
    public TestThread0() {
    }
    public TestThread0(ReentrantLock reentrantLock) {
        this.reentrantLock = reentrantLock;
    }
    @Override
    public void run() {
        if (reentrantLock.tryLock()) {
            try {
                System.out.println("进入" + Thread.currentThread().getName());
                Thread.sleep(7000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class TestThread1 implements Runnable {
    ReentrantLock reentrantLock;
    public TestThread1() {
    }
    public TestThread1(ReentrantLock reentrantLock) {
        this.reentrantLock = reentrantLock;
    }
    @Override
    public void run() {
        if (reentrantLock.tryLock()) {
            try {
                System.out.println("进入" + Thread.currentThread().getName());
                Thread.sleep(7000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }