CosId Универсальный, гибкий, высокопроизводительный распределенный генератор уникальных идентификаторов

cosid:
  snowflake:
    machine:
      distributor:
        type: manual
        manual:
          machine-id: 0

cosid:
  snowflake:
    machine:
      distributor:
        type: stateful_set

cosid:
  snowflake:
    machine:
      distributor:
        type: redis

cosid:
  snowflake:
    clock-backwards:
      spin-threshold: 10
      broken-threshold: 2000
```По умолчанию `DefaultClockBackwardsSynchronizer` использует стратегию активного ожидания для синхронизации обратной перемотки часов. `spinThreshold` (значение по умолчанию 10 миллисекунд) используется для установки порогового значения ожидания в режиме спиннинга. Когда значение больше `spinThreshold`, используется метод `Thread.sleep()` для ожидания синхронизации часов. Если значение превышает `brokenThreshold` (значение по умолчанию 2 секунды), выбрасывается исключение `ClockTooManyBackwardsException`.


### MachineStateStorage

```java
public class MachineState {
    public static final MachineState NOT_FOUND = of(-1, -1);
    private final int machineId;
    private final long lastTimestamp;

    public MachineState(int machineId, long lastTimestamp) {
        this.machineId = machineId;
        this.lastTimestamp = lastTimestamp;
    }

    public int getMachineId() {
        return machineId;
    }

    public long getLastTimestamp() {
        return lastTimestamp;
    }

    public static MachineState of(int machineId, long lastTimestamp) {
        return new MachineState(machineId, lastTimestamp);
    }
}

cosid:
  snowflake:
    machine:
      state-storage:
        local:
          state-location: ./cosid-machine-state/

cosid:
  snowflake:
    share:
      clock-sync: true

SnowflakeId snowflakeId = SafeJavaScriptSnowflakeId.ofMillisecond(1);

cosid:
  snowflake:
    share:
      friendly: true

public class SnowflakeIdState {

    private final long id;

    private final int machineId;

    private final long sequence;

    private final LocalDateTime timestamp;

    /**
     * {@link #timestamp}-{@link #machineId}-{@link #sequence}
     */
    private final String friendlyId;
}

public interface SnowflakeFriendlyId extends SnowflakeId {

    SnowflakeIdState friendlyId(long id);

    SnowflakeIdState ofFriendlyId(String friendlyId);

    default SnowflakeIdState friendlyId() {
        long id = generate();
        return friendlyId(id);
    }
}

    SnowflakeFriendlyId snowflakeFriendlyId = new DefaultSnowflakeFriendlyId(snowflakeId);
    SnowflakeIdState idState = snowflakeFriendlyId.friendlyId();
    idState.getFriendlyId(); //20210623131730192-1-0

cosid:
  segment:
    enabled: true
    distributor:
      type: redis

CREATE TABLE IF NOT EXISTS cosid (
    name VARCHAR(100) NOT NULL COMMENT '{namespace}.{name}',
    last_max_id BIGINT NOT NULL DEFAULT 0,
    last_fetch_time BIGINT NOT NULL,
    CONSTRAINT cosid_pk PRIMARY KEY (name)
) ENGINE = InnoDB;

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db
    username: root
    password: root
cosid:
  segment:
    enabled: true
    distributor:
      type: jdbc
      jdbc:
        enable-auto-init-cosid-table: false
        enable-auto-init-id-segment: true

INSERT INTO cosid (name, last_max_id, last_fetch_time) VALUES ('namespace.name', 0, UNIX_TIMESTAMP());

cosid:
  segment:
    enabled: true
    mode: chain
    chain:
      safe-distance: 5
      prefetch-worker:
        core-pool-size: 2
        prefetch-period: 1s
    distributor:
      type: redis
    share:
      offset: 0
      step: 100
    provider:
      bizC:
        offset: 10000
        step: 100
      bizD:
        offset: 10000
        step: 100

cosid:
  snowflake:
    provider:
      bizA:
        #timestamp-bit:
        sequence-bit: 12
      bizB:
        #timestamp-bit:
        sequence-bit: 12

IdGenerator idGenerator = idGeneratorProvider.get("bizA");

implementation("me.ahoo.cosid:cosid-mybatis:${cosidVersion}")

@Target(ElementType.FIELD)
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CosId {
    String value() default IdGeneratorProvider.SHARE;

    boolean friendlyId() default false;
}

public class LongIdEntity {

    @CosId(value = "safeJs")
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

public class FriendlyIdEntity {

    @CosId(friendlyId = true)
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

@Mapper
public interface OrderRepository {
    @Insert("insert into t_table (id) values (#{id});")
    void insert(LongIdEntity order);

    @Insert({
        "<script>",
        "insert into t_friendly_table (id)",
        "VALUES",
        "<foreach item='item' collection='list' open='' separator=',' close=''>",
        "(#{item.id})",
        "</foreach>",
        "</script>"
    })
    void insertList(List<FriendlyIdEntity> list);
}

LongIdEntity entity = new LongIdEntity();
entityRepository.insert(entity);
/**
 * {
 *   "id": 208796080181248
 * }
 */
return entity;

spring:
  shardingsphere:
    rules:
      sharding:
        key-generators:
          cosid:
            type: COSID
            props:
              id-name: __share__

spring:
  shardingsphere:
    rules:
      sharding:
        sharding-algorithms:
          alg-name:
            type: COSID_INTERVAL
            props:
              logic-name-prefix: logic-name-prefix
              id-name: cosid-name
              datetime-lower: 2021-12-08 22:00:00
              datetime-upper: 2022-12-01 00:00:00
              sharding-suffix-pattern: yyyyMM
              datetime-interval-unit: MONTHS
              datetime-interval-amount: 1

spring:
  shardingsphere:
    rules:
      sharding:
        sharding-algorithms:
          alg-name:
            type: COSID_MOD
            props:
              mod: 4
              logic-name-prefix: t_table_

val cosidVersion = "1.14.5";
implementation("me.ahoo.cosid:cosid-spring-boot-starter:${cosidVersion}")

<?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">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>demo</artifactId>
    <properties>
        <cosid.version>1.14.5</cosid.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>me.ahoo.cosid</groupId>
            <artifactId>cosid-spring-boot-starter</artifactId>
            <version>${cosid.version}</version>
        </dependency>
    </dependencies>
</project>

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/cosid_db_0
        username: root
        password: root
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/cosid_db_1
        username: root
        password: root
    props:
      sql-show: true
    rules:
      sharding:
        binding-tables:
          - t_order,t_order_item
        tables:
          cosid:
            actual-data-nodes: ds0.cosid
          t_table:
            actual-data-nodes: ds0.t_table_$->{0..1}
            table-strategy:
              standard:
                sharding-column: id
                sharding-algorithm-name: table-inline
          t_date_log:
            actual-data-nodes: ds0.t_date_log_202112
            key-generate-strategy:
              column: id
              key-generator-name: snowflake
            table-strategy:
              standard:
                sharding-column: create_time
                sharding-algorithm-name: data-log-interval
        sharding-algorithms:
          table-inline:
            type: COSID_MOD
            props:
              mod: 2
              logic-name-prefix: t_table_
          data-log-interval:
            type: COSID_INTERVAL
            props:
              logic-name-prefix: t_date_log_
              datetime-lower: 2021-12-08 22:00:00
              datetime-upper: 2022-12-01 00:00:00
              sharding-suffix-pattern: yyyyMM
              datetime-interval-unit: MONTHS
              datetime-interval-amount: 1
        key-generators:
          snowflake:
            type: COSID
            props:
              id-name: snowflake


cosid:
  namespace: ${spring.application.name}
  machine-device:
    enabled: true
    #      stability: true
    #      bit-machine-device: 10
    #      instance-id: ${HOSTNAME}
    distributor:
      type: redis
    #        manual:
    #          machine-id: 0
  snowflake:
    enabled: true
    #    epoch: 1577203200000
    back-time:
      spin-rate: 10
      break-rate: 2000
    availability:
      clock-sync: true
      friendliness: true
    provider:
      order_item:
        #        test-time-bit:
        sequence-bit: 12
      snowflake:
        sequence-bits: 12
      safeJs:
        machine-bit: 3
        sequence-bits: 9
  segment:
    enabled: true
    mode: chain
    chain:
      safety-distance: 5
      preprocessor-worker:
        main-pool-size: 2
        preprocessing-period: 1s
    distributor:
      type: redis
    availability:
      offset: 0
      step: 100
    provider:
      order:
        offset: 10000
        step: 100
      long-id:
        offset: 10000
        step: 100

gradle cosid-core:jmh
# или
java -jar cosid-core/build/libs/cosid-core-1.14.5-jmh.jar -bm thrpt -wi 1 -rf json -f 1

Benchmark                                                    Mode  Cnt        Score   Error  Units
SnowflakeIdBenchmark.millisecondSnowflakeId_friendlyId      thrpt       4020311.665          ops/s
SnowflakeIdBenchmark.millisecondSnowflakeId_generate        thrpt       4095403.859          ops/s
SnowflakeIdBenchmark.safeJsMillisecondSnowflakeId_generate  thrpt        511654.048          ops/s
SnowflakeIdBenchmark.safeJsSecondSnowflakeId_generate       thrpt        539818.563          ops/s
SnowflakeIdBenchmark.secondSnowflakeId_generate             thrpt       4206843.941          ops/s