xml复制代码<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2023.0.1.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-ai</artifactId>
    </dependency>
</dependencies>

yml复制代码server:
  port: 8080
spring:
  application:
    name: alibaba-spring-ai-demo

  cloud:
    ai:
      tongyi:
          api-key: 你的api-key

java复制代码@SpringBootApplication
public class MyAiApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyAiApplication.class,args);
    }
}

java复制代码@RestController
@RequestMapping("/ai")
@CrossOrigin
public class TongYiController {
    @Autowired
    @Qualifier("tongYiSimpleServiceImpl")
    private TongYiService tongYiSimpleService;

    @GetMapping("/simple")
    public String completion(
            @RequestParam(value = "message", defaultValue = "AI时代下Java开发者该何去何从？")
            String message
    ) {
        return tongYiSimpleService.completion(message);
    }
}

java复制代码public interface TongYiService {

    /**
     * 基本问答
     */
    String completion(String message);
    /**
     * 文生图
     */
    ImageResponse genImg(String imgPrompt);

    /**
     * 语音合成
     */
    String genAudio(String text);

}

java复制代码@Service
@Slf4j
public class TongYiSimpleServiceImpl extends AbstractTongYiServiceImpl {
  /**
   * 自动注入ChatClient、StreamingChatClient，屏蔽模型调用细节
   */
  private final ChatClient chatClient;

  private final StreamingChatClient streamingChatClient;

  @Autowired
  public TongYiSimpleServiceImpl(ChatClient chatClient, StreamingChatClient streamingChatClient) {
    this.chatClient = chatClient;
    this.streamingChatClient = streamingChatClient;
  }
    /**
    * 具体实现：
    */
  @Override
  public String completion(String message) {
    Prompt prompt = new Prompt(new UserMessage(message));
    return chatClient.call(prompt).getResult().getOutput().getContent();
  }
}

java复制代码@Slf4j
@Service
public class TongYiImagesServiceImpl extends AbstractTongYiServiceImpl {
    private static final Logger logger = LoggerFactory.getLogger(TongYiService.class);
    private final ImageClient imageClient;
    @Autowired
    public TongYiImagesServiceImpl(ImageClient client) {
       this.imageClient = client;
    }
    @Override
    public ImageResponse genImg(String imgPrompt) {
       var prompt = new ImagePrompt(imgPrompt);
       return imageClient.call(prompt);
    }
}

java复制代码@Slf4j
@Service
public class TongYiAudioSimpleServiceImpl extends AbstractTongYiServiceImpl {
    private static final Logger logger = LoggerFactory.getLogger(TongYiService.class);
    private final SpeechClient speechClient;
    @Autowired
    public TongYiAudioSimpleServiceImpl(SpeechClient client) {
       this.speechClient = client;
    }
    @Override
    public String genAudio(String text) {
       logger.info("gen audio prompt is: {}", text);
       var resWAV = speechClient.call(text);
       // save的代码省略，就是将音频保存到本地而已
       return save(resWAV, SpeechSynthesisAudioFormat.WAV.getValue());
    }
}

java复制代码import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RedissonBloomFilterUtil {

    private static final Logger logger = LoggerFactory.getLogger(RedissonBloomFilterUtil.class);

    private RBloomFilter<String> bloomFilter;
    private RedissonClient redissonClient;
    private CacheService cacheService; // 假设这是你的缓存服务
    private DatabaseService databaseService; // 假设这是你的数据库服务

    public RedissonBloomFilterUtil(RedissonClient redissonClient, CacheService cacheService, DatabaseService databaseService, long expectedInsertions, double falseProbability) {
        this.redissonClient = redissonClient;
        this.cacheService = cacheService;
        this.databaseService = databaseService;
        this.bloomFilter = redissonClient.getBloomFilter("bloomFilter");
        this.bloomFilter.tryInit(expectedInsertions, falseProbability);
    }

    public Object getData(String key) {
        try {
            if (!bloomFilter.contains(key)) {
                logger.debug("Bloom filter does not contain key: {}", key);
                return null;
            }

            Object cachedData = cacheService.getFromCache(key);
            if (cachedData != null) {
                logger.debug("Returning data from cache for key: {}", key);
                return cachedData;
            }

            Object databaseData = databaseService.getFromDatabase(key);
            if (databaseData != null) {
                cacheService.addToCache(key, databaseData);
                logger.debug("Data added to cache for key: {}", key);
                return databaseData;
            }

            logger.debug("Data not found in database for key: {}", key);
            recordFalsePositive(key);
        } catch (Exception e) {
            logger.error("Error retrieving data for key: {}", key, e);
            // Implement fallback strategy (e.g., retry logic, circuit breaker)
        }
        return null;
    }

    private void recordFalsePositive(String key) {
        // Implement logic to record false positives
        // This could involve logging or updating the bloom filter
        logger.info("Recorded false positive for key: {}", key);
    }

    public void rebuildBloomFilter() {
        // Implement logic to rebuild the bloom filter
        // This might involve clearing the bloom filter and re-adding keys from a reliable source
        logger.info("Rebuilding bloom filter");
    }

    // ... (shutdown method and other methods)
}

xml复制代码<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.4</version> 
</dependency>

java复制代码import org.redisson.api.RedissonClient;
import org.redisson.api.RAtomicLong;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

@Component
public class DistributedIdGenerator {

    private final RedissonClient redissonClient;
    private final ConcurrentMap<String, RAtomicLong> atomicLongCache;
    private static final String KEY_PREFIX = "id_generator_"; // 可配置化的键前缀
    private static final int ID_BATCH_SIZE = 100; // 批量生成 ID 的大小
    private long currentId = 0;
    private long maxId = 0;

    @Autowired
    public DistributedIdGenerator(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.atomicLongCache = new ConcurrentHashMap<>();
    }

    public synchronized String generateId(String prefix) {
        // 检查当前批次是否已用完
        if (currentId >= maxId) {
            // 从 Redis 获取下一个批次的起始 ID
            RAtomicLong atomicLong = atomicLongCache.computeIfAbsent(prefix, k -> redissonClient.getAtomicLong(KEY_PREFIX + k));
            currentId = atomicLong.addAndGet(ID_BATCH_SIZE);
            maxId = currentId + ID_BATCH_SIZE;
        }
        // 返回自定义前缀和 ID 的组合
        return prefix + "_" + (currentId++);
    }
}

java复制代码import org.redisson.api.RedissonClient;
import org.redisson.api.RAtomicLong;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;

@Component
public class DistributedIdGenerator {

    private final RedissonClient redissonClient;
    private final ConcurrentMap<String, AtomicLong> currentIdMap;
    private final ConcurrentMap<String, AtomicLong> maxIdMap;
    private static final String KEY_PREFIX = "id_generator_";
    private static final int ID_BATCH_SIZE = 100;
    private static final int PREFETCH_THRESHOLD = 10; // 当剩余 ID 少于此值时，开始预取

    @Autowired
    public DistributedIdGenerator(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.currentIdMap = new ConcurrentHashMap<>();
        this.maxIdMap = new ConcurrentHashMap<>();
    }

    public String generateId(String prefix) {
        AtomicLong currentId = currentIdMap.computeIfAbsent(prefix, k -> new AtomicLong(0));
        AtomicLong maxId = maxIdMap.computeIfAbsent(prefix, k -> new AtomicLong(0));

        long id = currentId.getAndIncrement();
        if (id >= maxId.get()) {
            synchronized (maxId) {
                if (id >= maxId.get()) {
                    RAtomicLong atomicLong = redissonClient.getAtomicLong(KEY_PREFIX + prefix);
					 long newMaxId = atomicLong.addAndGet(ID_BATCH_SIZE);
                    maxId.set(newMaxId);
                    currentId.set(newMaxId - ID_BATCH_SIZE + 1);
                    id = currentId.getAndIncrement();
                }
            }
        }

        // Prefetch next ID range if necessary
        long remainingIds = maxId.get() - currentId.get();
        if (remainingIds <= PREFETCH_THRESHOLD) {
            CompletableFuture.runAsync(() -> fetchNextIdRange(prefix));
        }

        return prefix + "_" + id;
    }
	private void fetchNextIdRange(String prefix) {
	    AtomicLong maxId = maxIdMap.get(prefix);
        synchronized (maxId) {
            // Double-check in case another thread already fetched the range
            if (currentIdMap.get(prefix).get() < maxId.get()) {
                return;
            }
            RAtomicLong atomicLong = redissonClient.getAtomicLong(KEY_PREFIX + prefix);
            long newMaxId = atomicLong.addAndGet(ID_BATCH_SIZE);
            maxId.set(newMaxId);
        }
    }
}

java复制代码import org.redisson.api.RedissonClient;
import org.redisson.api.RAtomicLong;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @Author derek_smart
 * @Date 202/4/25 10:15
 * @Description 分布式Id 最终版
 * <p>
 */
@Component
public class DistributedIdGenerator {

    private final RedissonClient redissonClient;
    private final ConcurrentMap<String, AtomicLong> currentIdMap;
    private final ConcurrentMap<String, AtomicLong> maxIdMap;
    private static final String KEY_PREFIX = "id_generator_";

    @Value("${id.generator.batch.size:100}")
    private int idBatchSize;

    @Value("${id.generator.prefetch.threshold:10}")
    private int prefetchThreshold;

    @Autowired
    public DistributedIdGenerator(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.currentIdMap = new ConcurrentHashMap<>();
        this.maxIdMap = new ConcurrentHashMap<>();
    }

    public String generateId(String prefix) {
        AtomicLong currentId = currentIdMap.computeIfAbsent(prefix, k -> new AtomicLong(0));
        AtomicLong maxId = maxIdMap.computeIfAbsent(prefix, k -> new AtomicLong(0));

        long id = currentId.getAndIncrement();
        if (id >= maxId.get()) {
            synchronized (maxId) {
                if (id >= maxId.get()) {
                    fetchNextIdRange(prefix, maxId);
                    id = currentId.getAndIncrement();
                }
            }
        }

        // Prefetch next ID range if necessary
        long remainingIds = maxId.get() - currentId.get();
        if (remainingIds <= prefetchThreshold) {
            fetchNextIdRange(prefix, maxId);
        }

        return prefix + "_" + id;
    }

    private void fetchNextIdRange(String prefix, AtomicLong maxId) {
        synchronized (maxId) {
            // Double-check in case another thread already fetched the range
            if (currentIdMap.get(prefix).get() < maxId.get()) {
                return;
            }
            RAtomicLong atomicLong = redissonClient.getAtomicLong(KEY_PREFIX + prefix);
            long newMaxId = atomicLong.addAndGet(idBatchSize);
            maxId.set(newMaxId);
        }
    }
}

java复制代码@Service
public class SomeService {

    @Autowired
    private DistributedIdGenerator idGenerator;

    public void doSomething() {
        // 生成一个带有自定义前缀 "xx" 的分布式 ID
        String distributedId = idGenerator.generateId("xx");
        // 使用生成的 ID 进行业务操作
    }
}

java复制代码@Configuration
public class RedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

java复制代码 import java.util.UUID;

 public class UUIDGenerator {
     public static String generateUUID() {
         return UUID.randomUUID().toString();
     }
 }

java复制代码
public class SnowflakeIdGenerator {

    private final long twepoch = 1288834974657L;
    private final long workerIdBits = 5L;
    private final long datacenterIdBits = 5L;
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    private final long sequenceBits = 12L;

    private final long workerIdShift = sequenceBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    private long workerId;
    private long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;

    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("Worker ID can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("Datacenter ID can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();

        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        return ((timestamp - twepoch) << timestampLeftShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift)
                | sequence;
    }

    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = new SnowflakeIdGenerator(0, 0);
        for (int i = 0; i < 1000; i++) {
            long id = idGenerator.nextId();
            System.out.println(id);
        }
    }
}

java复制代码import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicLong;

/
 * @Author derek_smart
 * @Date 202/4/26 10:25
 * @Description SnowflakeId id 生成器
 * <p>
 */
@Component
public class SnowflakeIdGenerator {

    private final long twepoch = 1288834974657L;
    private final long workerIdBits = 5L;
    private final long datacenterIdBits = 5L;
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    private final long sequenceBits = 12L;

    private final long workerIdShift = sequenceBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    private final long workerId;
    private final long datacenterId;
    private final AtomicLong sequence = new AtomicLong(0L);
    private final AtomicLong lastTimestamp = new AtomicLong(-1L);

    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("Worker ID can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("Datacenter ID can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    //异步单个
    public CompletableFuture<Long> nextIdAsync() {
        return CompletableFuture.supplyAsync(this::nextId);
    }
    //批量
    public List<Long> nextIds(int count) {
        List<Long> ids = new ArrayList<>(count);
        for (int i = 0; i < count; i++) {
            ids.add(nextId());
        }
        return ids;
    }
    //异步 多个
    public CompletableFuture<List<Long>> nextIdsAsync(int count) {
        return CompletableFuture.supplyAsync(() -> nextIds(count));
    }

    //获取
    public long nextId() {
        long currentTimestamp = -1L;
        long lastTimestampValue = -1L;

        while (true) {
            lastTimestampValue = lastTimestamp.get();
            currentTimestamp = timeGen();

            if (currentTimestamp < lastTimestampValue) {
                // Clock moved backwards, handle the exception
                throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestampValue - currentTimestamp));
            }

            if (currentTimestamp == lastTimestampValue) {
                long currentSequence = sequence.incrementAndGet() & sequenceMask;
                if (currentSequence == 0) {
                    currentTimestamp = waitNextMillis(currentTimestamp);
                } else {
                    return generateId(currentTimestamp, currentSequence);
                }
            } else {
                if (sequence.compareAndSet(sequence.get(), 0L)) {
                    return generateId(currentTimestamp, sequence.get());
                }
            }
        }
    }

    private long generateId(long currentTimestamp, long sequence) {
        return ((currentTimestamp - twepoch) << timestampLeftShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift)
                | sequence;
    }

    private long waitNextMillis(long currentTimestamp) {
        while (currentTimestamp <= lastTimestamp.get()) {
            currentTimestamp = timeGen();
        }
        lastTimestamp.set(currentTimestamp);
        return currentTimestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }
}

java复制代码import org.springframework.stereotype.Component;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/
 * @Author derek_smart
 * @Date 202/4/26 10:45
 * @Description 双重缓存 SnowflakeId id 生成器
 * <p>
 */
@Component
public class BufferedSnowflakeIdGenerator {

    private final Lock bufferLock = new ReentrantLock();
    private final SnowflakeIdGenerator snowflakeIdGenerator;
    private AtomicReference<long[]> bufferOne;
    private AtomicReference<long[]> bufferTwo;
    private AtomicLong bufferIndex;
    private AtomicReference<long[]> currentBuffer;
    private final ExecutorService executorService;

    private final int bufferSize;

    private String customPrefix;

    public BufferedSnowflakeIdGenerator(long workerId, long datacenterId, int bufferSize) {
        this.snowflakeIdGenerator = new SnowflakeIdGenerator(workerId, datacenterId);
        this.bufferSize = bufferSize;
        this.bufferOne = new AtomicReference<>(new long[bufferSize]);
        this.bufferTwo = new AtomicReference<>(new long[bufferSize]);
        this.bufferIndex = new AtomicLong(-1);
        this.currentBuffer = new AtomicReference<>(bufferOne.get());
        this.executorService = Executors.newSingleThreadExecutor();

        // Initial buffer fill
        fillBuffer(bufferOne.get());
        fillBuffer(bufferTwo.get());
    }

    public BufferedSnowflakeIdGenerator(long workerId, long datacenterId, int bufferSize, String customPrefix) {
        this.snowflakeIdGenerator = new SnowflakeIdGenerator(workerId, datacenterId);
        this.bufferSize = bufferSize;
        this.bufferOne = new AtomicReference<>(new long[bufferSize]);
        this.bufferTwo = new AtomicReference<>(new long[bufferSize]);
        this.bufferIndex = new AtomicLong(-1);
        this.currentBuffer = new AtomicReference<>(bufferOne.get());
        this.executorService = Executors.newSingleThreadExecutor();
        this.customPrefix = customPrefix;
        // Initial buffer fill
        fillBuffer(bufferOne.get());
        fillBuffer(bufferTwo.get());
    }


    private void fillBuffer(long[] buffer) {
        try {
            for (int i = 0; i < bufferSize; i++) {
                buffer[i] = snowflakeIdGenerator.nextId();
            }
        } catch (Exception e) {
            // Handle exceptions during buffer fill here
            e.printStackTrace();
        }
    }

    /
     * 带自定义
     * @return
     */
    public String nextIdWithPrefix() {
        return customPrefix + "_" + nextId();
    }

    /*
     * 不带自定义表示
     * @return
     */
    public long nextId() {
        long index = bufferIndex.incrementAndGet();
        if (index < bufferSize) {
            return currentBuffer.get()[(int) index];
        } else {
            bufferLock.lock();
            try {
                // Double check inside the lock
                index = bufferIndex.get();
                if (index >= bufferSize) {
                    currentBuffer.set(currentBuffer.get() == bufferOne.get() ? bufferTwo.get() : bufferOne.get());
                    bufferIndex.set(0);
                    index = 0;
                    // Trigger buffer refill asynchronously
                    long[] bufferToFill = currentBuffer.get() == bufferOne.get() ? bufferTwo.get() : bufferOne.get();
                    executorService.submit(() -> fillBuffer(bufferToFill));
                }
            } finally {
                bufferLock.unlock();
            }
            return currentBuffer.get()[(int) index];
        }
    }

    public void shutdown() {
        executorService.shutdown();
        // Optionally add code to wait for termination and handle tasks that could not be executed
    }

    // Ensure to call shutdown when the application stops
    protected void finalize() throws Throwable {
        try {
            shutdown();
        } finally {
            super.finalize();
        }
    }
}

java复制代码public interface IdGenerationStrategy {
    long generateId();
}

java复制代码public class SnowflakeStrategy implements IdGenerationStrategy {

    // ... (其他成员变量和构造函数保持不变)

    @Override
    public long generateId() {
        return nextId();
    }

    // ... (nextId, waitNextMillis, timeGen, generateId 方法保持不变)
}

java复制代码import java.util.UUID;

public class UUIDStrategy implements IdGenerationStrategy {

    @Override
    public long generateId() {
        // UUIDs are 128-bit values, but we need to return a long (64-bit)
        // This can be done by taking the hash of the UUID for example
        return UUID.randomUUID().toString().hashCode();
    }
}

java复制代码public class IdGeneratorFactory {

    private static IdGenerationStrategy idGeneratorStrategy;

    public static synchronized IdGenerationStrategy getIdGeneratorStrategy() {
        if (idGeneratorStrategy == null) {
            // The choice of strategy can be made configurable
            // For example, based on system properties, configuration files, etc.
            String strategyType = System.getProperty("id.generator.strategy", "snowflake");
            if ("snowflake".equals(strategyType)) {
                long workerId = ...; // Retrieve from configuration
                long datacenterId = ...; // Retrieve from configuration
                idGeneratorStrategy = new SnowflakeStrategy(workerId, datacenterId);
            } else if ("uuid".equals(strategyType)) {
                idGeneratorStrategy = new UUIDStrategy();   
				} else {
                throw new IllegalArgumentException("Unknown ID Generator strategy type");
            }
        }
        return idGeneratorStrategy;
    }
}

java复制代码public class IdGenerationClient {

    public static void main(String[] args) {
        IdGenerationStrategy idGenerator = IdGeneratorFactory.getIdGeneratorStrategy();
        long id = idGenerator.generateId();
        System.out.println("Generated ID: " + id);
    }
}

java复制代码/**
 * 方式1：传入Runnable实例并立刻运行
 */
@Test
public void test1() {
    // 方式1：传入Runnable实例并立刻运行:
    Thread vt = Thread.startVirtualThread(() -> {
        System.out.println("Start virtual thread...");
    });

    //这样也行
    Thread.ofVirtual().start(() -> {
        System.out.println("Start virtual thread...");
    });
}

/**
 * 方式2：传入Runnable实例并后置运行
 */
@Test
public void test2() {
    Thread vt = Thread.ofVirtual().unstarted(() -> {
        System.out.println("Start virtual thread...");
    });
    vt.start();
}

/**
 * 方式3：创建ThreadFactory
 */
@Test
public void test3() {
    ThreadFactory tf = Thread.ofVirtual().factory();
    Thread vt = tf.newThread(() -> {
        System.out.println("Start virtual thread...");
    });
    vt.start();
}


/**
 * 方式4：使用ExecutorService  （但是每次submit仍然是新创建虚拟线程 java.util.concurrent.ThreadPerTaskExecutor）
 */
@Test
public void test4() {
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    executor.submit(() -> {
        System.out.println("Start virtual thread...");
        return true;
    });
}

java复制代码try (var scope = new StructuredTaskScope<>()) {
    // 使用fork方法派生线程来执行子任务
    StructuredTaskScope.Subtask<String> future1 = scope.fork(() -> "111");
    StructuredTaskScope.Subtask<Integer> future2 = scope.fork(() -> 222);

    // 等待线程完成
    scope.join();
    // 结果的处理可能包括处理或重新抛出异常

    System.out.println(future1.get());
    System.out.println(future2.get());

} // close
catch (InterruptedException e) {
    throw new RuntimeException(e);
}

C#复制代码public class UserBll
{
    public static readonly int CACHE_NULL_TTL = 10;
    public static readonly int CACHE_TTL = 20;
    /** 
     * 缓存穿透* 
     * @param id 
     * @ return 
     */
    public WebUserInfo QueryUser(string key)
    {
        var redis = Redis.GetDatabase(0);
        // 1.从redis中查询store缓存
        String value = redis.StringGet(key);
        WebUserInfo user = null;
        // 2.判断是否存在
        if( value.HasValue() ) {
            user = value.FromJson<WebUserInfo>();
            // 3.存在，直接返回
            return user;
        }
        // 判断命中是否为空值
        if ( value == null) {
            // 返回错误信息
            return null;
        }
        // 4.不存在，根据id查询数据库
        user = DatabaseQuery(key);
        // 5. 不存在，返回错误
        if( user == null ) {
            // 向redis写入空值（缓存穿透）
            redis.StringSet(key, "", new TimeSpan(0, CACHE_NULL_TTL, 0));
            return null;
        }
        // 6.存在，写入redis
        redis.StringSet(key, user.ToJson(), new TimeSpan(0, CACHE_TTL, 0));
        // 7. 返回
        return user;
}


    public WebUserInfo DatabaseQuery(string key)
    {
        // 模拟从数据库中查询数据
        // 实际情况下，这里可以是访问数据库、调用外部 API 等操作
        // 这里简化为返回 null
        return null;
    }


}

class Program
{
    static void Main(string[] args)
    {
        UserBll cache = new UserBll();

        // 第一次查询，缓存中不存在，但是查询结果为空
        string result1 = cache.QueryUser("key1");
        Console.WriteLine("Result 1: " + result1); // Output: Result 1: (null)

        // 第二次查询，缓存中已存在空对象缓存，直接返回空值
        string result2 = cache.QueryUser("key1");
        Console.WriteLine("Result 2: " + result2); // Output: Result 2: (null)

        // 第三次查询，模拟数据库中存在对应值的情况
        string result3 = cache.QueryUser("key2");
        Console.WriteLine("Result 3: " + result3); // Output: Result 3: <value from database>
    }
}

C#复制代码using System;
using System.Collections.Generic;
using System.Threading;

public class Cache
{
    private Dictionary<string, string> cache = new Dictionary<string, string>();
    private Mutex mutex = new Mutex();

    public string Get(string key)
    {
        // 先尝试从缓存中获取数据
        string value;
        if (cache.TryGetValue(key, out value))
        {
            return value;
        }

        // 如果缓存中不存在，加锁查询数据库
        mutex.WaitOne();
        try
        {
            // 再次检查缓存，防止多个线程同时查询数据库
            if (cache.TryGetValue(key, out value))
            {
                return value;
            }

            // 模拟从数据库中查询数据
            value = QueryFromDatabase(key);

            // 将查询结果更新到缓存中
            cache[key] = value;
        }
        finally
        {
            mutex.ReleaseMutex();
        }

        return value;
    }

    private string QueryFromDatabase(string key)
    {
        // 模拟从数据库中查询数据的过程
        Thread.Sleep(100); // 模拟耗时查询操作
        return "value for " + key;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Cache cache = new Cache();

        // 并发查询
        List<Thread> threads = new List<Thread>();
        for (int i = 0; i < 10; i++)
        {
            Thread thread = new Thread(() =>
            {
                string value = cache.Get("key");
                Console.WriteLine(Thread.CurrentThread.Name + ": " + value);
            });
            thread.Name = "Thread " + i;
            threads.Add(thread);
        }

        foreach (Thread thread in threads)
        {
            thread.Start();
        }

        foreach (Thread thread in threads)
        {
            thread.Join();
        }
    }
}

java复制代码private Lock lock = new ReentrantLock();
lock.lock();//加锁
//执行一些操作
...
lock.unlock();//解锁

java复制代码//直接尝试获取锁，没有获取则直接返回
boolean tryLock();  
//在一定时间尝试获取锁，否则等待获取锁，超时会返回 false  
boolean tryLock(long var1, TimeUnit var3) throws InterruptedException;

csharp复制代码Lock lock = new ReentrantLock();  
if(lock.tryLock()) {
    //执行一些操作
    ...
    lock.unlock();  
} else {  
   //未获取锁的操作
}

java复制代码Condition condition = lock.newCondition();  
try {  
    condition.await();  
} catch (InterruptedException e) {  
    throw new RuntimeException(e);  
}  
condition.signalAll();

java复制代码ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
Lock readLock = readWriteLock.readLock(); //获取读锁
Lock writeLock = readWriteLock.writeLock();//获取写锁

java复制代码/*
*使用StampedLock读操作模板
*/
final StampedLock sl = new StampedLock();  
// 乐观读 ，获取 stamp 版本号
long stamp = sl.tryOptimisticRead();  
// 读取共享变量，并用局部变量保存
......  
// 校验 stamp 版本号
if (!sl.validate(stamp)){  
    // 如果失败，则升级为悲观读锁  
    stamp = sl.readLock();  
    try {  
    // 再次读取共享变量，并用局部变量保存
    .....  
    } finally {  
        // 释放悲观读锁  
        sl.unlockRead(stamp);  
    }  
}  
// 执行业务操作  
......



/*
*使用StampedLock写操作模板
*/
long stamp = sl.writeLock();   
try {  
    // 写共享变量  
    ......  
} finally {  
    sl.unlockWrite(stamp);  
}

java复制代码//限制只有四个线程可以访问
//第5个线程会被阻塞，直到其他线程release
Semaphore semaphore = new Semaphore(4);  
try {  
    semaphore.acquire();  
    //执行操作
    ...
} catch (InterruptedException e) {  
    throw new RuntimeException(e);  
} finally {  
    semaphore.release();  
}

scss复制代码final CountDownLatch countDownLatch = new CountDownLatch(2);  
Runnable runnable1 = new Runnable() {  
    @Override  
    public void run() {  
        //获取用户的id 
        ...
        //计数减一
        countDownLatch.countDown();  
    }  
};  
Runnable runnable2 = new Runnable() {  
    @Override  
    public void run() {  
        //获取其他用户的id 
        ...
        //计数减一
        countDownLatch.countDown();  
    }  
};  
Runnable runnable3 = new Runnable() {  
@Override  
public void run() {  
    try {  
        //等待其他线程执行完成  
        countDownLatch.await();  
        //判断两个人是否是好友 
        ...
    } catch (InterruptedException e) {  
        throw new RuntimeException(e);  
    }  
}  
};  
new Thread(runnable1).start();  
new Thread(runnable2).start();  
new Thread(runnable3).start();

java复制代码final CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {  
    @Override  
    public void run() {  
        //计数归0时的回调 
        ...
    }  
});
Runnable runnable1 = new Runnable() {  
    @Override  
    public void run() {  
        while (是否满足退出条件) {  
            try {  
                //执行操作 
                ...
                //阻塞线程，计数减少1  
                cyclicBarrier.await();  
                //执行操作 
                ...
            } catch (InterruptedException | BrokenBarrierException e) {  
                throw new RuntimeException(e);  
            }  
        }  
    }  
};

Runnable runnable2 = new Runnable() {  
    @Override  
    public void run() {  
        while (是否满足退出条件) {  
            try {  
                //执行操作 
                ...
                //阻塞线程，计数减少1  
                cyclicBarrier.await();  
                //执行操作 
                ...
            } catch (InterruptedException | BrokenBarrierException e) {  
                throw new RuntimeException(e);  
            }  
        }  
    }  
};
new Thread(runnable1).start();  
new Thread(runnable2).start();

java复制代码int[] v = new int[]{1, 2, 3};  
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(v);  
int value = atomicIntegerArray.get(0);  
System.out.println(atomicIntegerArray.compareAndSet(0, value, 100));

java复制代码Test test = new Test();  
AtomicReference<Test> atomicReference = new AtomicReference<>(test);  
atomicReference.compareAndSet(atomicReference.get(), new Test());

ini复制代码Test test = new Test();  
test.id = 0;  
AtomicIntegerFieldUpdater<Test> updater = AtomicIntegerFieldUpdater.newUpdater(Test.class, "id");  
//获取当前对象的id值，并加1
updater.getAndIncrement(test);

java复制代码LongAdder longAdder = new LongAdder();  
longAdder.increment();

arduino复制代码ThreadPoolExecutor(  
        int corePoolSize,  
        int maximumPoolSize,  
        long keepAliveTime,  
        TimeUnit unit,  
        BlockingQueue<Runnable> workQueue,  
        ThreadFactory threadFactory,  
        RejectedExecutionHandler handler)

java复制代码class SumTask extends RecursiveTask<Long> {
    protected Long compute() {
        if(判断是否需要拆分任务) {
            //创建两个子任务
            SumTask task1 = new SumTask(...);
            SumTask task2 = new SumTask(...);
            // invokeAll会并行运行两个子任务:
            invokeAll(task1, task2);
            // 等待获得子任务的结果:
            Long result1 = task1.join();
            Long result2 = task2.join();
            return result1 + result2;
        } else {
            //执行sum操作
            ...
            return result;
        }
    }
}


ForkJoinTask<Long> task = new SumTask(...);
Long result = ForkJoinPool.commonPool().invoke(task);

java复制代码//串行任务，任务1、2、3串行执行
CompletableFuture<String> result =  
    CompletableFuture.supplyAsync(() -> "hello")  //任务1
    .thenApply(s -> s + " world");  //任务2
    .thenApply(String::toUpperCase);  //任务3
System.out.println(result.join());


//汇聚关系
CompletableFuture<String> result =  
    CompletableFuture.supplyAsync(() -> "a")  
    .thenCombineAsync(CompletableFuture.supplyAsync(() -> "b"),  
    (a, b) -> a + b );  
System.out.println(result.join());

java复制代码ExecutorService executorService = Executors.newFixedThreadPool(3);  
CompletionService<Integer> completionService = new ExecutorCompletionService<>(executorService);  
completionService.submit(() -> {  //任务1
    Thread.sleep(200);  
    return 1;  
});  
completionService.submit(() -> {  //任务2
    Thread.sleep(100);  
    return 2;  
});  
completionService.submit(() -> {  //任务3
    Thread.sleep(150);  
    return 3;  
});  
int sum = 0;  
for(int i = 0; i < 3; i++) {  
    try {  
        //这里获取顺序是 2 3 1
        sum += completionService.take().get();  
        System.out.println(sum);  
    } catch (InterruptedException | ExecutionException e) {  
        throw new RuntimeException(e);  
    }  
}

xml复制代码<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

java复制代码@Configuration
public class CaffeineConfig {
    @Bean
    public Cache<String,Object> caffeineCache(){
        return Caffeine.newBuilder()
                .initialCapacity(128)//初始大小
                .maximumSize(1024)//最大数量
                .expireAfterWrite(60, TimeUnit.SECONDS)//过期时间
                .build();
    }
}

java复制代码@Resource
private Cache<String, Object> cache;
@Resource
private RedisTemplate<String, Object> redisTemplate;
@Test
void testCache() {
    // 缓存测试存取
    cache.put("test", "test");
    assertEquals("test", cache.getIfPresent("test"));

    //实现二级缓存读取
    cache.get("test",
              k -> {
                  //先查询 Redis
                  Object obj = redisTemplate.opsForValue().get(k);
                  if (Objects.nonNull(obj)) {
                      System.out.println("缓存命中：" + k + " 从 Redis 读取成功");
                      return obj;
                  }

                  // Redis没有则查询 DB
                  System.out.println("缓存没有命中：" + k + " 从 DB 读取");
                  // 从 DB 读取 ..此处模拟省略
                  obj = "test";
                  // 存入 Redis
                  redisTemplate.opsForValue().set(k, "test");
                  //存入本地缓存由cache.get执行
                  return obj;
              });

}

xml复制代码<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

java复制代码@Configuration
public class CacheManagerConfig {
    @Bean
    public CacheManager cacheManager(){
        CaffeineCacheManager cacheManager=new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(128)
                .maximumSize(1024)
                .expireAfterWrite(60, TimeUnit.SECONDS));
        return cacheManager;
    }
}

java复制代码@SpringBootApplication()
@EnableCaching
public class Application {

}

java复制代码@Resource
private RedisTemplate<String,Object> redisTemplate;
@Cacheable(value = "test",key = "#id")
public String getStringTextById(Long id) {
    String key= "test" + id;
    //先查询 Redis
    String obj = (String) redisTemplate.opsForValue().get(key);
    if (Objects.nonNull(obj)){
        log.info("从Redis中获取数据");
        return obj;
    }
    // Redis没有则查询 DB
    log.info("从DB中获取数据");
    //此处省略查询DB的代码
    obj = "test";
    //redis 中存入
    redisTemplate.opsForValue().set(key,obj,120, TimeUnit.SECONDS);
    return obj;
}

bash复制代码#参数名
#参数对象.属性名
#参数为数组对应下标

java复制代码@CachePut(cacheNames = "test",key = "#id")
public String updateOrder(String testData, Long id) {
    log.info("更新数据");
    //更新数据库 此处省略
    //修改 Redis
    redisTemplate.opsForValue().set("test" + id,
                                    testData, 120, TimeUnit.SECONDS);
    //返回要缓存本地的数据
    return testData;
}

java复制代码@CacheEvict(cacheNames = "test",key = "#id")
public void deleteOrder(Long id) {
    log.info("删除数据");
    //此处省略删除数据库的代码
    //删除 Redis
    redisTemplate.delete("test" + id);
}