bash复制代码sudo apt-get install openssh-server openssh-client

bash复制代码sudo ufw allow 22

sql复制代码systemctl start ssh

bash复制代码ping www.baidu.com -t #正常
ping 虚拟机ip   #正常

bash复制代码 ip link

arduino复制代码 sudo nano /etc/netplan/00-installer-config.yaml

yaml复制代码network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      dhcp4: true

yaml复制代码network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      dhcp4: false
      addresses: [192.168.2.168/24]
      gateway4: 192.168.2.1

bash复制代码 sudo netplan apply

css复制代码ip address show ens33

bash复制代码
rh@ronhai:~$ ip address show ens33
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:ad:53:d9 brd ff:ff:ff:ff:ff:ff
    altname enp2s1
    inet 192.168.2.168/24 brd 192.168.2.255 scope global ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::20c:29ff:fead:53d9/64 scope link
       valid_lft forever preferred_lft forever

ini复制代码[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn

sh复制代码mkdir -p ~/.pip && echo "[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn" > ~/.pip/pip.conf

sh复制代码pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package

ini复制代码[global]
index-url = https://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host = mirrors.aliyun.com

ini复制代码[global]
index-url = https://pypi.mirrors.ustc.edu.cn/simple/
[install]
trusted-host = pypi.mirrors.ustc.edu.cn

ini复制代码[global]
index-url = https://pypi.doubanio.com/simple/
[install]
trusted-host = pypi.doubanio.com

ini复制代码[global]
index-url = https://mirrors.huaweicloud.com/repository/pypi/simple
[install]
trusted-host = mirrors.huaweicloud.com

ini复制代码[global]
index-url = https://mirrors.cloud.tencent.com/pypi/simple
[install]
trusted-host = mirrors.cloud.tencent.com

sh复制代码pip install -i https://mirrors.aliyun.com/pypi/simple/ some-package

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.1</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>ai</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <dependencies>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
            <version>0.8.0-SNAPSHOT</version>
        </dependency>


    </dependencies>
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>

</project>

yaml复制代码server:
  port: 8088

spring:
  ai:
    openai:
      base-url: https://api.openai.com/
      api-key: sk-xxx
      embedding:
        options:
          model: text-davinci-003
      chat:
        #指定某一个API配置(覆盖全局配置)
        api-key: sk-xxx
        base-url: https://api.openai.com/
        options:
          model: gpt-3.5-turbo # 模型配置

kotlin复制代码package com.et.ai.controller;

import jakarta.annotation.Resource;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.embedding.EmbeddingResponse;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
public class HelloWorldController {
    @Autowired
    EmbeddingClient embeddingClient;
    @Autowired
    ChatClient chatClient;
    @GetMapping("/ai/embedding")
    public Map embed(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        EmbeddingResponse embeddingResponse = this.embeddingClient.embedForResponse(List.of(message));
        return Map.of("embedding", embeddingResponse);
    }
    @GetMapping("/ai/chat")
    public String chat(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        Prompt prompt = new Prompt(message);
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }
}

typescript复制代码package com.et.ai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

go复制代码package main

import "fmt"

type Celsius float64
type Fahrenheit float64

func main() {
	var f Fahrenheit = 100
	var c Celsius
	c = Celsius((f - 32) * 5 / 9)
	fmt.Println("Temperature in Celsius:", c)
}

go复制代码package main

import "fmt"

func main() {
	var i interface{} = 10
	value, ok := i.(int)
	if ok {
		fmt.Println("Value:", value)
	} else {
		fmt.Println("Conversion failed")
	}
}

go复制代码package main

import "fmt"

type Animal struct {
	Name string
}

type Dog struct {
	*Animal
	Breed string
}

func main() {
	animal := Animal{Name: "Animal"}
	dog := Dog{Animal: &animal, Breed: "Labrador"}

	fmt.Println("Dog name:", dog.Name)
}

go复制代码var i interface{} = "hello"
if value, ok := i.(int); ok {
    fmt.Println("Value:", value)
} else {
    fmt.Println("Conversion failed")
}

go复制代码type Animal struct {
    Name string
}

type Dog struct {
    *Animal
    Breed string
}

func main() {
    animal := Animal{Name: "Animal"}
    dog := Dog{Animal: &animal, Breed: "Labrador"}

    fmt.Println("Dog name:", dog.Name)
}

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);
}