线偶的IT笔记

01 RedissonLock

线偶发布于 2024-04-08 收录于源码分析 Redisson 系列

redisson 基于 org.redisson:redisson-spring-data-27:3.27.2 版本

在 java 中，操作 redis 一般都会选择 redisson 框架, 我们需要了解常用功能的实现原理, 这次来介绍 RedissonLock。

使用方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@Test
void testDistributedLock() {
    RLock lock = redissonClient.getLock("lock");
    try {
        lock.lock();
        ThreadUtil.sleep(30, TimeUnit.SECONDS);
        System.out.println("xxx");
    } finally {
        lock.unlock();
    }
}

上面是最常见分布式锁使用示例, redisson 的锁分为好几种，我们先以 RedissonLock 来说明。

05 TreeMap

线偶发布于 2024-04-03 收录于源码分析 Jdk 系列

jdk 基于 8 版本

在平时的开发中，我们很少会用到 TreeMap, 但是还是需要了解源码。 TreeMap 基于红黑树来实现按照 key 排序，关于这个算法，这里不做解释。

使用方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class TreeMapTest {

    @Test
    void test() {
        Map<String, String> map = new TreeMap<>();
        map.put("1", "a");
        map.put("2", "b");
        assertThat(map.remove("1")).isEqualTo("a");
        assertThat(map.put("2", "c")).isEqualTo("b");
        assertThat(map.get("2")).isEqualTo("c");
    }
}

因为是 Map 接口的实现类，所以使用方式是差不多的。只不过在遍历过程中，是按照 key 值排序的。

04 LinkedHashMap

线偶发布于 2024-04-02 收录于源码分析 Jdk 系列

jdk 基于 8 版本

在平时的开发中，我们会经常用到 LinkedHashMap, 非常有必要了解源码。
LinkedHashMap 基于 HashMap 来实现, 内部借助双向链表来维持访问顺序，可以用来实现 LRU 算法。

使用方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class LinkedHashMapTest {

    @Test
    void test() {
        Map<String, String> map = new LinkedHashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        assertThat(map.remove("1")).isEqualTo("a");
        assertThat(map.put("2", "c")).isEqualTo("b");
        assertThat(map.get("2")).isEqualTo("c");
    }
}

对于使用方式来说，LinkedHashMap 和 HashMap 是一样的，只不过 LinkedHashMap 在遍历过程中是有序的, 实现原理是在添加元素时，需要把元素移动到双向链表的尾部，然后遍历时直接取双向链表。

03 HashMap

线偶发布于 2024-04-01 收录于源码分析 Jdk 系列

jdk 基于 8 版本

在平时的开发中，我们会经常用到 HashMap, 非常有必要了解源码。
HashMap 基于拉链法和红黑树来实现，关于这两个算法，这里不做解释。

使用方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class HashMapTest {

    @Test
    void test() {
        Map<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        assertThat(map.remove("1")).isEqualTo("a");
        assertThat(map.put("2", "c")).isEqualTo("b");
        assertThat(map.get("2")).isEqualTo("c");
    }
}

put

源码位置: java.util.HashMap#put

时间轮和线程池实现任务执行器

线偶发布于 2024-03-24 收录于随笔

java 的线程池可以充当一个任务执行器的，但是有时候不符合我们的要求，所以需要自定义开发。
满足1：可以根据任务数量来动态调整核心线程数和最大线程数。
满足2：支持重复执行的任务。

实现一个软引用缓存

线偶发布于 2024-03-20 收录于随笔

在 java 中有四种引用类型，分为强引用，软引用，弱引用，虚引用，这里介绍如何使用软引用来实现一个缓存。

实现代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class SoftReferenceCache<K, V> implements Cache<K, V> {

    private Map<K, SoftValue<V>> map;

    private ReferenceQueue<V> referenceQueue;

    public SoftReferenceCache() {
        this.map = new HashMap<>();
        this.referenceQueue = new ReferenceQueue<>();
    }

    @Override
    public void put(K key, V value) {
        removeSoftValue();
        this.map.put(key, new SoftValue<>(key, value, referenceQueue));
    }

    @Override
    public V get(K key) {
        removeSoftValue();
        SoftValue<V> softValue = this.map.get(key);
        return softValue.getValue();
    }

    // 这里没有使用额外的线程来定时执行方法
    protected void removeSoftValue() {
        while (true) {
            SoftValue<V> softValue = (SoftValue<V>) referenceQueue.poll();
            if (softValue == null) {
                break;
            }
            System.out.println("remove unnecessary softValue: " + softValue);
            map.remove(softValue.getKey());
        }
    }

    private class SoftValue<V> extends SoftReference<V> {
        
        // 从引用队列中获取此对象，就能知道是哪个key和value要回收了。
        private K key;

        public SoftValue(K key, V value, ReferenceQueue<V> referenceQueue) {
            super(value, referenceQueue);
            this.key = key;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return super.get();
        }

        @Override
        public String toString() {
            return "SoftValue{" +
                "key=" + key +
                '}';
        }
    }
}

测试代码

注意: 我在 build.gradle 文件中添加了 test 的 jvm 参数 jvmArgs = ["-Xmx10m", “-Xms10m”], 来模拟内存不足来触发回收软引用。