ConcurrentHashMap原理及使用详解

class ConcurrentHashMap<K, V> {
    final Segment[] segments;
    class Segment extends ReentrantLock implements Serializable{
        // 每个 Segment 自己独立的哈希表
        private final Map<K,V> map = new HashMap<>();
        // Segment 内部加锁机制，确保线程安全
        public synchronized V put(K key, V value) {
            return map.put(key, value);
        }
    }
    // 获取 key 所属的 Segment 的索引
    private int getSegmentIndex(K key) {
        int hash = hash(key.hashCode()); // 对 hashcode() 进行哈希
        int segmentMask = segments.length - 1; // mask 值
        return hash & segmentMask; // 按位与，定位具体的 Segment
    }
    public V put(K key, V value) {
        Segment s = segments[getSegmentIndex(key)];
        s.lock(); // 获取 s 对应的 Segment 的锁
        try {
            return s.put(key, value); // 在 s 上进行 put 操作
        } finally {
            s.unlock(); // 释放 s 对应的 Segment 的锁
        }
    }
}

import java.util.concurrent.ConcurrentHashMap;
public class Counter {
    private final ConcurrentHashMap<String, Integer> map;
    public Counter() {
        this.map = new ConcurrentHashMap<>();
    }
    public void increase(String key) {
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
    public int get(String key) {
        return map.getOrDefault(key, 0);
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class TaskManager {
    private final ConcurrentHashMap<String, TaskInfo> tasks;
    public TaskManager() {
        this.tasks = new ConcurrentHashMap<>();
    }
    public void addTask(String taskId, Runnable task) {
        // 添加任务信息
        tasks.put(taskId, new TaskInfo());
        // 提交任务到线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.submit(() -> {
            try {
                // 执行任务
                task.run();
                // 更新任务状态和结果
                TaskInfo info = tasks.get(taskId);
                info.setStatus(TaskStatus.COMPLETED);
                info.setResult("Task completed successfully!");
            } catch (Exception ex) {
                // 更新任务状态和结果
                TaskInfo info = tasks.get(taskId);
                info.setStatus(TaskStatus.FAILED);
                info.setResult(ex.getMessage());
            }
        });
        // 关闭线程池
        executor.shutdown();
    }
    public TaskInfo getTaskInfo(String taskId) {
        return tasks.getOrDefault(taskId, new TaskInfo());
    }
}
enum TaskStatus {
    NEW,
    RUNNING,
    COMPLETED,
    FAILED;
}
class TaskInfo {
    private TaskStatus status;
    private String result;
    public TaskInfo() {
        this.status = TaskStatus.NEW;
        this.result = "";
    }
    public TaskStatus getStatus() {
        return status;
    }
    public void setStatus(TaskStatus status) {
        this.status = status;
    }
    public String getResult() {
        return result;
    }
    public void setResult(String result) {
        this.result = result;
    }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CacheManager<K, V> {
    private final Map<K, CacheEntry<V>> cache;
    public CacheManager() {
        this.cache = new ConcurrentHashMap<>();
    }
    public void put(K key, V value, long ttl) {
        // 添加缓存项，同时记录当前时间戳和缓存生存时间
        CacheEntry<V> entry = new CacheEntry<>(value, System.currentTimeMillis(), ttl);
        cache.put(key, entry);
    }
    public V get(K key) {
        // 获取缓存项和其缓存生存时间
        CacheEntry<V> entry = cache.get(key);
        // 检查缓存项是否过期，如果过期则删除缓存项并返回 null
        if (entry != null && !entry.isExpired()) {
            return entry.getValue();
        } else {
            cache.remove(key);
            return null;
        }
    }
    static class CacheEntry<V> {
        private final V value;
        private final long timestamp;
        private final long ttl;
        public CacheEntry(V value, long timestamp, long ttl) {
            this.value = value;
            this.timestamp = timestamp;
            this.ttl = ttl;
        }
        public V getValue() {
            return value;
        }
        public boolean isExpired() {
            return System.currentTimeMillis() - timestamp > ttl;
        }
    }
}