精通Java并发锁机制：24种锁技巧+业务锁匹配方案

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Race {
    private final CyclicBarrier barrier;

    public Race(int numberOfRunners) {
        barrier = new CyclicBarrier(numberOfRunners, () -> {
            System.out.println("比赛开始！");
            // 这里可以放置所有参与者到达屏障后要执行的操作
        });
    }

    public void run() {
        System.out.println("等待其他参赛者...");
        try {
            barrier.await(); // 等待其他线程
            System.out.println("开始跑步！");
            // 跑步时间
            Thread.sleep((long) (Math.random() * 10000));
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final int numberOfRunners = 5;
        Race race = new Race(numberOfRunners);

        // 创建参赛者线程
        for (int i = 0; i < numberOfRunners; i++) {
            final int runnerNumber = i + 1;
            new Thread(() -> {
                System.out.println("参赛者 " + runnerNumber + " 已准备就绪");
                race.run();
            }).start();
        }
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DataProcessingPipeline {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    private final CyclicBarrier barrier;
    private final int numberOfPhases;
    private final int numberOfTasks;

    public DataProcessingPipeline(int numberOfTasks, int numberOfPhases) {
        this.numberOfTasks = numberOfTasks;
        this.numberOfPhases = numberOfPhases;
        this.barrier = new CyclicBarrier(numberOfTasks, () -> {
            System.out.println("一个阶段完成，准备进入下一阶段");
        });
    }

    public void processData() throws Exception {
        for (int phase = 1; phase <= numberOfPhases; phase++) {
            System.out.println("阶段 " + phase + " 开始");
            for (int task = 0; task < numberOfTasks; task++) {
                final int currentTask = task;
                executor.submit(() -> {
                    try {
                        // 数据处理任务
                        System.out.println("任务 " + currentTask + " 在阶段 " + phase + " 执行");
                        Thread.sleep((long) (Math.random() * 5000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            barrier.await();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
            barrier.await(); // 等待所有任务完成
        }
        executor.shutdown();
    }

    public static void main(String[] args) {
        DataProcessingPipeline pipeline = new DataProcessingPipeline(4, 3);
        try {
            pipeline.processData();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

public class Counter {
    // 使用 AtomicInteger 来确保计数器的线程安全
    private final AtomicInteger count = new AtomicInteger(0);

    // 提供一个方法来增加计数器的值
    public void increment() {
        // 原子地增加计数器的值
        count.incrementAndGet();
    }

    // 提供一个方法来获取当前计数器的值
    public int getCount() {
        // 原子地获取计数器的值
        return count.get();
    }
}

public class DataStore {
    // 使用 AtomicLong 来统计数据总量
    private final AtomicLong dataCount = new AtomicLong(0);

    public void addData(long size) {
        // 原子地将数据大小累加到总量
        dataCount.addAndGet(size);
    }

    public long getDataCount() {
        // 原子地获取当前数据总量
        return dataCount.get();
    }
}

// 测试类
public class AtomicVariablesDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();
        DataStore dataStore = new DataStore();

        // 多线程环境中对计数器和数据总量的更新
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                counter.increment();
                dataStore.addData(100);  // 假设每次操作增加100单位数据
            }).start();
        }

        // 等待所有线程完成
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }

        // 输出计数器的值和数据总量
        System.out.println("Counter value: " + counter.getCount());
        System.out.println("Data store size: " + dataStore.getDataCount());
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class MessageNotificationCounter {
    private final AtomicInteger messageCount = new AtomicInteger(0);

    // 接收新消息时调用此方法
    public void receiveMessage() {
        // 原子地增加消息计数
        messageCount.incrementAndGet();
        System.out.println("New message received. Total messages: " + messageCount.get());
    }

    // 用户阅读消息时调用此方法
    public void messagesRead() {
        // 原子地减少消息计数
        messageCount.decrementAndGet();
        System.out.println("Messages read. Remaining messages: " + messageCount.get());
    }

    // 获取当前消息计数
    public int getMessageCount() {
        return messageCount.get();
    }
}

// 测试类
public class AtomicVariablesDemo {
    public static void main(String[] args) {
        MessageNotificationCounter counter = new MessageNotificationCounter();

        // 多个用户同时发送消息
        Thread sender1 = new Thread(() -> {
            counter.receiveMessage();
        });
        Thread sender2 = new Thread(() -> {
            counter.receiveMessage();
        });

        // 用户阅读消息
        Thread reader = new Thread(() -> {
            counter.messagesRead();
        });

        sender1.start();
        sender2.start();
        reader.start();

        sender1.join();
        sender2.join();
        reader.join();

        System.out.println("Final message count: " + counter.getMessageCount());
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapDemo {
    // 创建一个 ConcurrentHashMap 实例
    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    // 将一个键值对插入到 Map 中
    public void put(String key, Integer value) {
        // put 方法是线程安全的
        map.put(key, value);
    }

    // 从 Map 中获取与指定键关联的值
    public Integer get(String key) {
        // get 方法是线程安全的
        return map.get(key);
    }

    // 计算 Map 中的元素数量
    public int size() {
        // size 方法是线程安全的
        return map.size();
    }

    // 演示删除操作
    public void remove(String key) {
        // remove 方法是线程安全的
        map.remove(key);
    }

    // 演示如何批量添加数据
    public void addAll(Map<String, Integer> newData) {
        // putAll 方法是线程安全的
        map.putAll(newData);
    }

    public static void main(String[] args) {
        ConcurrentHashMapDemo demo = new ConcurrentHashMapDemo();

        // 批量添加数据
        demo.addAll(Map.of("key1", 1, "key2", 2, "key3", 3));

        // 单独添加一条数据
        demo.put("key4", 4);

        // 获取并打印一条数据
        System.out.println("Value for 'key1': " + demo.get("key1"));

        // 获取 Map 的大小
        System.out.println("Map size: " + demo.size());

        // 删除一条数据
        demo.remove("key2");

        // 再次获取 Map 的大小
        System.out.println("Map size after removal: " + demo.size());
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

public class DistributedCache<K, V> {
    private final ConcurrentHashMap<K, V> cacheMap = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<K, Long> expirationMap = new ConcurrentHashMap<>();

    public void put(K key, V value, long ttl) {
        cacheMap.put(key, value);
        expirationMap.put(key, System.currentTimeMillis() + ttl);
        scheduleEviction(key, ttl);
    }

    public V get(K key) {
        Long expirationTime = expirationMap.get(key);
        if (expirationTime == null || expirationTime < System.currentTimeMillis()) {
            cacheMap.remove(key);
            expirationMap.remove(key);
            return null;
        }
        return cacheMap.get(key);
    }

    private void scheduleEviction(final K key, final long ttl) {
        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(ttl);
                cacheMap.computeIfPresent(key, (k, v) -> null);
                expirationMap.remove(key);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }

    public static void main(String[] args) {
        DistributedCache<String, String> cache = new DistributedCache<>();
        cache.put("userSession", "sessionData", 5000); // 缓存设置5秒过期

        // 多个线程并发访问缓存
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            new Thread(() -> {
                String result = cache.get("userSession");
                System.out.println("Thread " + finalI + " retrieved: " + result);
            }).start();
        }
    }
}

import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrentSkipListMapDemo {
    // 创建一个 ConcurrentSkipListMap 实例
    private final ConcurrentSkipListMap<Integer, String> map = new ConcurrentSkipListMap<>();

    // 将一个键值对插入到 Map 中
    public void put(Integer key, String value) {
        // put 方法是线程安全的
        map.put(key, value);
    }

    // 从 Map 中获取与指定键关联的值
    public String get(Integer key) {
        // get 方法是线程安全的
        return map.get(key);
    }

    // 获取 Map 的键集合
    public java.util.NavigableSet<Integer> keySet() {
        // keySet 方法返回 Map 的键集合视图
        return map.keySet();
    }

    // 获取 Map 的值集合
    public java.util.Collection<String> values() {
        // values 方法返回 Map 的值集合视图
        return map.values();
    }

    // 获取 Map 的大小
    public int size() {
        // size 方法是线程安全的
        return map.size();
    }

    // 演示删除操作
    public void remove(Integer key) {
        // remove 方法是线程安全的
        map.remove(key);
    }

    public static void main(String[] args) {
        ConcurrentSkipListMapDemo demo = new ConcurrentSkipListMapDemo();

        // 插入一些数据
        demo.put(1, "One");
        demo.put(2, "Two");
        demo.put(3, "Three");

        // 获取并打印一条数据
        System.out.println("Value for key 2: " + demo.get(2));

        // 获取 Map 的大小
        System.out.println("Map size: " + demo.size());

        // 获取并打印所有键
        System.out.println("All keys: " + demo.keySet());

        // 删除一条数据
        demo.remove(2);

        // 再次获取 Map 的大小
        System.out.println("Map size after removal: " + demo.size());

        // 获取并打印所有值
        System.out.println("All values: " + demo.values());
    }
}

import java.util.concurrent.ConcurrentSkipListMap;

public class StockPriceIndex {
    private final ConcurrentSkipListMap<String, Double> priceIndex = new ConcurrentSkipListMap<>();

    public void updatePrice(String stockSymbol, Double newPrice) {
        // 更新股票价格
        priceIndex.put(stockSymbol, newPrice);
    }

    public Double getPrice(String stockSymbol) {
        // 获取股票价格
        return priceIndex.get(stockSymbol);
    }

    public void removeStock(String stockSymbol) {
        // 移除股票信息
        priceIndex.remove(stockSymbol);
    }

    public ConcurrentSkipListMap<String, Double> headMap(String toKey) {
        // 获取指定范围内的股票价格索引
        return priceIndex.headMap(toKey);
    }

    public static void main(String[] args) {
        StockPriceIndex index = new StockPriceIndex();
        index.updatePrice("AAPL", 150.00);
        index.updatePrice("GOOGL", 2750.50);
        index.updatePrice("MSFT", 250.00);

        System.out.println("Price of AAPL: " + index.getPrice("AAPL"));
        System.out.println("Price of GOOGL: " + index.getPrice("GOOGL"));

        // 获取所有小于 "MSFT" 的股票价格索引
        ConcurrentSkipListMap<String, Double> subMap = index.headMap("MSFT");
        subMap.forEach((k, v) -> System.out.println("Stock: " + k + ", Price: " + v));
    }
}

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueDemo {
    // 创建一个 ConcurrentLinkedQueue 实例
    private final ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

    // 向队列中添加元素
    public void add(int number) {
        // add 方法是线程安全的
        queue.add(number);
        System.out.println("Added " + number);
    }

    // 从队列中获取并移除元素
    public Integer poll() {
        // poll 方法是线程安全的，返回并移除队列头部的元素
        Integer result = queue.poll();
        if (result != null) {
            System.out.println("Polled " + result);
        } else {
            System.out.println("Queue is empty");
        }
        return result;
    }

    // 查看队列头部的元素但不移除
    public Integer peek() {
        // peek 方法是线程安全的，返回队列头部的元素但不移除
        Integer result = queue.peek();
        if (result != null) {
            System.out.println("Peeked " + result);
        } else {
            System.out.println("Queue is empty");
        }
        return result;
    }

    // 获取队列的大小
    public int size() {
        // size 方法估算队列的大小
        int size = queue.size();
        System.out.println("Queue size: " + size);
        return size;
    }

    public static void main(String[] args) {
        ConcurrentLinkedQueueDemo demo = new ConcurrentLinkedQueueDemo();

        // 启动生产者线程
        Thread producerThread = new Thread(() -> {
            demo.add(1);
            demo.add(2);
            demo.add(3);
        });

        // 启动消费者线程
        Thread consumerThread = new Thread(() -> {
            demo.poll();
            demo.poll();
            demo.poll();
            demo.poll(); // 这次调用应该会返回 null，因为队列已空
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();

        // 在所有线程完成后获取队列大小
        demo.size();
    }
}

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LogProcessor {
    private final ConcurrentLinkedQueue<String> logQueue = new ConcurrentLinkedQueue<>();
    private final ExecutorService processorPool = Executors.newFixedThreadPool(10);

    public void log(String message) {
        // 生产者线程调用此方法来添加日志到队列
        logQueue.add(message);
    }

    public void startLogProcessing() {
        // 消费者线程池，用于处理队列中的日志
        processorPool.submit(() -> {
            while (true) {
                try {
                    // 消费者线程调用此方法来处理队列中的日志
                    String logEntry = logQueue.poll();
                    if (logEntry != null) {
                        processLog(logEntry);
                    } else {
                        TimeUnit.MILLISECONDS.sleep(100); // 避免 CPU 过载
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
    }

    private void processLog(String logEntry) {
        // 实际处理日志的逻辑
        System.out.println("Processing log: " + logEntry);
    }

    public static void main(String[] args) {
        LogProcessor logProcessor = new LogProcessor();
        logProcessor.startLogProcessing();

        // 多个生产者线程生成日志
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            new Thread(() -> {
                logProcessor.log("Log entry " + finalI);
            }).start();
        }
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueDemo {
    // 创建一个 LinkedBlockingQueue 实例，容量限制为10
    private final BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>(10);

    // 向 BlockingQueue 中添加元素
    public void produce(Integer element) throws InterruptedException {
        // put 方法在队列满时阻塞，直到队列中有空间
        blockingQueue.put(element);
        System.out.println("Produced: " + element);
    }

    // 从 BlockingQueue 中获取元素
    public Integer consume() throws InterruptedException {
        // take 方法在队列空时阻塞，直到队列中有元素
        Integer element = blockingQueue.take();
        System.out.println("Consumed: " + element);
        return element;
    }

    // 获取 BlockingQueue 的大小
    public int size() {
        // size 方法返回队列当前的元素数量
        return blockingQueue.size();
    }

    public static void main(String[] args) throws InterruptedException {
        BlockingQueueDemo demo = new BlockingQueueDemo();

        // 创建生产者线程
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    demo.produce(i);
                    Thread.sleep(100); // 生产延时
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 创建消费者线程
        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    int element = demo.consume();
                    Thread.sleep(150); // 消费延时
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();

        // 打印最终队列的大小
        System.out.println("Final queue size: " + demo.size());
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class MessageQueueSystem {
    private final BlockingQueue<Message> messageQueue = new LinkedBlockingQueue<>();

    public void produceMessage(String content) throws InterruptedException {
        // 将消息添加到队列中，如果队列满了，生产者线程将被阻塞
        messageQueue.put(new Message(content));
        System.out.println("Message produced: " + content);
    }

    public Message consumeMessage() throws InterruptedException {
        // 从队列中取出消息，如果队列空了，消费者线程将被阻塞
        Message message = messageQueue.take();
        System.out.println("Message consumed: " + message.getContent());
        return message;
    }

    public static void main(String[] args) throws InterruptedException {
        MessageQueueSystem messageQueueSystem = new MessageQueueSystem();

        // 创建生产者线程
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    messageQueueSystem.produceMessage("Message " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 创建消费者线程
        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    messageQueueSystem.consumeMessage();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();
    }
}

class Message {
    private final String content;

    public Message(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer {
    private final Object[] buffer;
    private int putPtr, takePtr, count;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public BoundedBuffer(int size) {
        buffer = new Object[size];
    }

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == buffer.length) { // 等待直到缓冲区非满
                notFull.await();
            }
            buffer[putPtr] = x;
            putPtr = (putPtr + 1) % buffer.length;
            count++;
            notEmpty.signal(); // 通知可能等待的消费者
        } finally {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) { // 等待直到缓冲区非空
                notEmpty.await();
            }
            Object x = buffer[takePtr];
            takePtr = (takePtr + 1) % buffer.length;
            count--;
            notFull.signal(); // 通知可能等待的生产者
            return x;
        } finally {
            lock.unlock();
        }
    }
}

public class ProducerConsumerDemo {
    private final BoundedBuffer buffer;

    public ProducerConsumerDemo(int size) {
        buffer = new BoundedBuffer(size);
    }

    public void produce(String item) {
        buffer.put(item);
    }

    public String consume() {
        return (String) buffer.take();
    }

    public static void main(String[] args) throws InterruptedException {
        final int SIZE = 10;
        final ProducerConsumerDemo demo = new ProducerConsumerDemo(SIZE);

        // 生产者线程
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                demo.produce("Item " + i);
                try {
                    Thread.sleep(100); // 生产延时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 消费者线程
        Thread consumerThread = new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                String item = demo.consume();
                System.out.println("Consumed: " + item);
                try {
                    Thread.sleep(150); // 消费延时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        producerThread.start();
        consumerThread.start();

        producerThread.join();
        consumerThread.join();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Date;
import java.util.LinkedList;
import java.util.Queue;

public class TaskScheduler {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition taskAvailable = lock.newCondition();
    private final Queue<Runnable> tasks = new LinkedList<>();

    public void schedule(Runnable task, long delay) {
        lock.lock();
        try {
            tasks.add(() -> {
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                task.run();
            });
            taskAvailable.signal(); // 通知调度器有新任务
        } finally {
            lock.unlock();
        }
    }

    public void startScheduling() {
        new Thread(this::runScheduler).start();
    }

    private void runScheduler() {
        lock.lock();
        try {
            while (true) {
                while (tasks.isEmpty()) { // 如果没有任务，等待
                    taskAvailable.await();
                }
                Runnable task = tasks.poll();
                task.run();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler();
        scheduler.schedule(() -> System.out.println("Task 1 executed at " + new Date()), 2000);
        scheduler.schedule(() -> System.out.println("Task 2 executed at " + new Date()), 4000);
        scheduler.startScheduling();
    }
}