千万级电商线上无阻塞双buffer缓冲优化ID生成机制深度解析

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
public class DoubleBufferIdGenerator {
private final ArrayBlockingQueue<Long> buffer1 = new ArrayBlockingQueue<>(1000);
private final ArrayBlockingQueue<Long> buffer2 = new ArrayBlockingQueue<>(1000);
private final AtomicBoolean isBuffer1Active = new AtomicBoolean(true);
private Thread idGeneratorThread;
public DoubleBufferIdGenerator() {
        startIdGeneratorThread();
    }
private void startIdGeneratorThread() {
        idGeneratorThread = new Thread(() -> {
long currentId = 0;
while (true) {
try {
if (isBuffer1Active.get()) {
                        fillBuffer(buffer1, currentId, 1000);
                        currentId += 1000;
                        isBuffer1Active.set(false);
                    } else {
                        fillBuffer(buffer2, currentId, 1000);
                        currentId += 1000;
                        isBuffer1Active.set(true);
                    }
// Sleep for a while to avoid tight loop
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
break;
                }
            }
        });
        idGeneratorThread.setDaemon(true);
        idGeneratorThread.start();
    }
private void fillBuffer(ArrayBlockingQueue<Long> buffer, long startId, int size) {
try {
for (int i = 0; i < size; i++) {
                buffer.put(startId + i);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
public synchronized Long generateId() throws InterruptedException {
        ArrayBlockingQueue<Long> activeBuffer = isBuffer1Active.get() ? buffer1 : buffer2;
        ArrayBlockingQueue<Long> inactiveBuffer = isBuffer1Active.get() ? buffer2 : buffer1;
        Long id;
while ((id = activeBuffer.poll()) == null) {
// If the active buffer is empty, wait until the generator thread fills it up
            wait();
        }
// Notify the generator thread if the inactive buffer is empty and needs refilling
if (inactiveBuffer.isEmpty()) {
            notifyAll();
        }
return id;
    }
public static void main(String[] args) {
DoubleBufferIdGenerator generator = new DoubleBufferIdGenerator();
try {
for (int i = 0; i < 2500; i++) {
                System.out.println("Generated ID: " + generator.generateId());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.*;
public class OptimizedDoubleBufferIdGenerator {
private final BlockingQueue<Long> buffer1 = new ArrayBlockingQueue<>(1000);
private final BlockingQueue<Long> buffer2 = new ArrayBlockingQueue<>(1000);
private final ExecutorService executor = Executors.newSingleThreadExecutor();
private final Semaphore semaphore = new Semaphore(1);
private final CountDownLatch latch = new CountDownLatch(1);
private volatile BlockingQueue<Long> activeBuffer = buffer1;
private volatile BlockingQueue<Long> inactiveBuffer = buffer2;
private final AtomicLong currentId = new AtomicLong(0);
public OptimizedDoubleBufferIdGenerator() {
        startIdGeneratorThread();
    }
private void startIdGeneratorThread() {
        executor.submit(() -> {
try {
                latch.await(); // Wait until the main thread is ready
while (true) {
long startId = currentId.getAndAdd(1000);
                    fillBuffer(inactiveBuffer, startId, 1000);
// Switch buffers
                    BlockingQueue<Long> temp = activeBuffer;
                    activeBuffer = inactiveBuffer;
                    inactiveBuffer = temp;
// Notify the main thread that a new buffer is ready
                    semaphore.release();
// Sleep for a while to avoid tight loop
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
private void fillBuffer(BlockingQueue<Long> buffer, long startId, int size) {
try {
for (int i = 0; i < size; i++) {
                buffer.put(startId + i);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
public Long generateId() throws InterruptedException {
// Acquire a permit from the semaphore
        semaphore.acquire();
        Long id;
while ((id = activeBuffer.poll()) == null) {
// If the active buffer is empty, wait until it is refilled
            Thread.sleep(1);
        }
return id;
    }
public static void main(String[] args) throws InterruptedException {
OptimizedDoubleBufferIdGenerator generator = new OptimizedDoubleBufferIdGenerator();
        generator.latch.countDown(); // Signal the generator thread to start
for (int i = 0; i < 2500; i++) {
            System.out.println("Generated ID: " + generator.generateId());
        }
        generator.executor.shutdown();
    }
}

import redis.clients.jedis.Jedis;
import java.util.concurrent.atomic.AtomicLong;
public class RedisDoubleBufferIdGenerator {
private final Jedis jedis;
private final String bufferKey1 = "id_buffer:1";
private final String bufferKey2 = "id_buffer:2";
private final String activeBufferKeyKey = "active_buffer_key";
private final AtomicLong currentId = new AtomicLong(0);
public RedisDoubleBufferIdGenerator(Jedis jedis) {
this.jedis = jedis;
        initializeBuffers();
    }
private void initializeBuffers() {
        jedis.del(bufferKey1, bufferKey2, activeBufferKeyKey);
        jedis.rpush(bufferKey1, generateIdRange(0, 999));
        jedis.set(activeBufferKeyKey, bufferKey1);
    }
private String generateIdRange(long start, long end) {
StringBuilder sb = new StringBuilder();
for (long i = start; i <= end; i++) {
            sb.append(i).append(",");
        }
return sb.toString().substring(0, sb.length() - 1);
    }
public synchronized Long generateId() {
String activeBufferKey = jedis.get(activeBufferKeyKey);
Long id = Long.parseLong(jedis.lpop(activeBufferKey));
if (jedis.llen(activeBufferKey) == 0) {
// Switch to the inactive buffer
String inactiveBufferKey = activeBufferKey.equals(bufferKey1) ? bufferKey2 : bufferKey1;
            jedis.rpush(inactiveBufferKey, generateIdRange(currentId.getAndAdd(1000), currentId.get() - 1));
            jedis.set(activeBufferKeyKey, inactiveBufferKey);
        }
return id;
    }
public static void main(String[] args) {
try (Jedis jedis = new Jedis("localhost", 6379)) {
RedisDoubleBufferIdGenerator generator = new RedisDoubleBufferIdGenerator(jedis);
for (int i = 0; i < 2500; i++) {
                System.out.println("Generated ID: " + generator.generateId());
            }
        }
    }
}