Java 基础

new LinkedHashMap<>(16,0.75f,true) // accessOrder = true

public V put(K key, V value) {
    // 扰动哈希，减少碰撞
    int hash = spread(key.hashCode());
    // 计算桶索引
    int i = (table.length - 1) & hash;

    // 如果桶是空的，直接 CAS 插入（无锁）
    if (tabAt(table, i) == null) {
        if (casTabAt(table, i, null, new Node<>(hash, key, value, null))) {
            return null;
        }
    }

    // 否则进入加锁流程
    synchronized (table[i]) {
        // 链表插入或树形插入逻辑...
    }
    return null;
}

private void putVal(int hash, K key, V value) {
    int i = (n - 1) & hash;
    Node<K, V> f = tabAt(table, i);

    if (f == null) {
        if (casTabAt(table, i, null, new Node<>(hash, key, value, null))) {
            return;
        }
    } else {
        synchronized (f) { // 局部加锁，只锁定当前桶位
            Node<K, V> e = f;
            while (e != null) {
                if (e.hash == hash && Objects.equals(e.key, key)) {
                    e.value = value; // 覆盖已有 key 的值
                    return;
                }
                e = e.next;
            }
            // 插入新节点
            f.next = new Node<>(hash, key, value, null);
        }
    }
}

private void putVal(int hash, K key, V value) {
    int i = (n - 1) & hash;
    Node<K, V> f = tabAt(table, i);

    if (f != null) {
        int binCount = 1;
        Node<K, V> e = f;
        while (e.next != null) {
            binCount++;
            e = e.next;
        }

        if (binCount >= TREEIFY_THRESHOLD) { // 默认值为8
            treeifyBin(table, i); // 转为红黑树结构
        }
    }
}

private void resize() {
    Node<K, V>[] oldTab = table;
    int oldCap = oldTab.length;
    int newCap = oldCap << 1;
    Node<K, V>[] newTab = new Node[newCap];

    for (int i = 0; i < oldCap; ++i) {
        Node<K, V> e = oldTab[i];
        if (e != null) {
            transferNode(e, newTab); // 将链表或树迁移到新表
        }
    }

    table = newTab;
}

private void test() {
    TreeMap<Integer, String> productMap = new TreeMap<>();
    productMap.put(102, "iPhone");
    productMap.put(101, "Samsung");
    productMap.put(103, "Huawei");

// 遍历时 key 是按顺序排序的（101, 102, 103）
    for (Map.Entry<Integer, String> entry : productMap.entrySet()) {
        System.out.println(entry.getKey() + " -> " + entry.getValue());
    }
}

private void test() {
    TreeMap<Long, String> transactionMap = new TreeMap<>();
    transactionMap.put(1707052800000L, "订单 A");  // 2024-02-05 00:00:00
    transactionMap.put(1707139200000L, "订单 B");  // 2024-02-06 00:00:00
    transactionMap.put(1707225600000L, "订单 C");  // 2024-02-07 00:00:00

    // 获取 2 月 5 日到 2 月 6 日之间的交易
    Map<Long, String> result = transactionMap.subMap(1707052800000L, 1707139200000L);
    System.out.println(result);
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": Hello from thread!");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        // 启动线程
        thread.start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": Hello from Runnable!");
    }

    public static void main(String[] args) {
        MyRunnable task = new MyRunnable();
        Thread thread = new Thread(task);  // 将任务传递给线程
        thread.start();  // 启动线程
    }
}

import java.util.concurrent.Callable;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000); // 模拟耗时操作
        return "Hello from Callable";
    }
}

import java.util.concurrent.*;

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Callable<String> task = () -> {
            Thread.sleep(1000);
            return "Callable task completed";
        };

        Future<String> future = executor.submit(task); // 提交 Callable 任务

        // 可以做其他事情
        System.out.println("Main thread doing other things...");

        // 获取结果（会阻塞直到任务完成）
        String result = future.get();
        System.out.println("Task result: " + result);

        executor.shutdown();
    }
}

private static volatile Singleton instance;

public static Singleton getInstance() {
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                // volatile保证以下操作不重排：
                // 1. memory = allocate() 分配空间
                // 2. init(memory) 初始化对象 ← StoreStore屏障在此
                // 3. instance = memory 设置引用 ← StoreLoad屏障在此
                instance = new Singleton();
            }
        }
    }
    return instance; // LoadLoad屏障保证读到最新值
}

private void test() {
    synchronized (lock) {
        while (!condition) {
            lock.wait();
        }
        // do something
        lock.notify();
    }
}

Thread.sleep(1000); // 休眠1秒

private void test() {
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    lock.lock();
    try {
        while (!conditionSatisfied) {
            condition.await();  // 等待
        }
        // 条件满足后执行逻辑
        condition.signal();     // 唤醒一个等待线程
    } finally {
        lock.unlock();
    }
}

private void test() {
    LockSupport.park();  // 阻塞当前线程
    LockSupport.unpark(thread);  // 唤醒指定线程
}

private void test() {
    //创建一个固定大小的线程池，该线程池可以容纳固定数量的线程。它适用于负载较为稳定的场景，线程数固定。
    ExecutorService executor = Executors.newFixedThreadPool(5);

    //创建一个可缓存的线程池。该线程池会根据需要创建新线程，如果某个线程长时间没有被使用，它会被回收。
    ExecutorService executor = Executors.newCachedThreadPool();

    //创建一个单线程的线程池，所有任务会按照提交的顺序依次执行。
    ExecutorService executor = Executors.newSingleThreadExecutor();

    //创建一个定时任务线程池，支持任务的延迟执行和定期执行。
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);

    //创建一个工作窃取线程池，线程池会自动调整线程的数量，适用于有多个任务需要并发执行的场景。
    ExecutorService executor = Executors.newWorkStealingPool();
}

private void test() {
    List<Callable<Integer>> tasks = new ArrayList<>();
    tasks.add(() -> {
        return 1;
    });
    tasks.add(() -> {
        return 2;
    });
    List<Future<Integer>> results = executor.invokeAll(tasks);
}

Integer result = executor.invokeAny(tasks);

private void test() {
    ExecutorService executor = Executors.newFixedThreadPool(2);

    Callable<Integer> task = () -> {
        // 执行任务
        return 1 + 1;
    };

    Future<Integer> future = executor.submit(task);
    Integer result = future.get(); // 获取任务执行结果
}

public class ThreadLocalExample {
    private static ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        // 模拟多线程环境
        Runnable task = () -> {
            int value = threadLocalValue.get();
            System.out.println(Thread.currentThread().getName() + " initial value: " + value);
            threadLocalValue.set(value + 1); // 修改该线程的副本
            System.out.println(Thread.currentThread().getName() + " modified value: " + threadLocalValue.get());
        };

        // 启动两个线程
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
    }
}

import com.alibaba.ttl.TransmittableThreadLocal;

public class TransmittableThreadLocalExample {
    private static TransmittableThreadLocal<Integer> transmittableThreadLocalValue = new TransmittableThreadLocal<>();

    public static void main(String[] args) {
        transmittableThreadLocalValue.set(10);  // 设置主线程中的值

        // 模拟一个线程池中的任务
        Runnable task = () -> {
            Integer value = transmittableThreadLocalValue.get();
            System.out.println(Thread.currentThread().getName() + " value: " + value); // 子线程继承了主线程的值
        };

        // 启动线程池任务
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
    }
}