Redis 분산ID 솔루션은 무엇인가요?

일반적으로 사용되는 분산 ID 솔루션

분산 시스템에서는 전역적으로 고유한 ID를 생성하는 것이 매우 중요합니다. 분산 시스템에서는 여러 노드가 동시에 ID를 생성하면 ID 충돌이 발생할 수 있기 때문입니다.

다음은 일반적으로 사용되는 여러 가지 분산 ID 솔루션을 소개합니다.

UUID

UUID(Universally Unique Identifier)는 128자리로 구성된 식별자로, 생성 알고리즘이 타임스탬프, 노드 ID 등의 요소를 기반으로 하기 때문에 전역적 고유성을 보장할 수 있습니다. UUID는 아래와 같이 Java와 함께 제공되는 UUID 클래스를 사용하여 생성할 수 있습니다.

javaCopy code
import java.util.UUID;
public class UuidGenerator {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid.toString());
    }
}

Java와 함께 제공되는 UUID 클래스는 매우 간단하고 사용하기 쉽고 추가 구성 및 관리가 필요하지 않다는 장점이 있습니다. UUID는 길이(128비트)로 인해 데이터베이스 테이블의 기본 키로 적합하지 않으며 정렬 및 색인이 어렵습니다.

Snowflake

Snowflake는 트위터에서 오픈소스로 제공하는 분산 ID 생성 알고리즘으로 타임스탬프, 데이터 센터 ID, 컴퓨터 ID 등의 정보가 포함된 64비트 고유 ID를 생성할 수 있습니다. Snowflake 알고리즘의 Java 코드는 다음과 같습니다.

Snowflake 알고리즘의 Java 코드:

javaCopy code
public class SnowflakeGenerator {
    private final static long START_STMP = 1480166465631L;
    private final static long SEQUENCE_BIT = 12;
    private final static long MACHINE_BIT = 5;
    private final static long DATACENTER_BIT = 5;
    private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
    private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
    private final static long MACHINE_LEFT = SEQUENCE_BIT;
    private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
    private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;
    private long datacenterId;
    private long machineId;
    private long sequence = 0L;
    private long lastStmp = -1L;
    public SnowflakeGenerator(long datacenterId, long machineId) {
        if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
            throw new IllegalArgumentException("datacenterId can&#39;t be greater than MAX_DATACENTER_NUM or less than 0");
        }
        if (machineId > MAX_MACHINE_NUM || machineId < 0) {
            throw new IllegalArgumentException("machineId can&#39;t be greater than MAX_MACHINE_NUM or less than 0");
        }
        this.datacenterId = datacenterId;
        this.machineId = machineId;
    }
    public synchronized long nextId() {
        long currStmp = getNewstmp();
        if (currStmp < lastStmp) {
            throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
        }
        if (currStmp == lastStmp) {
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0L) {
                currStmp = getNextMill();
            }
        } else {
            sequence = 0L;
        }
        lastStmp = currStmp;
        return (currStmp - START_STMP) << TIMESTMP_LEFT
                | datacenterId << DATACENTER_LEFT
                | machineId << MACHINE_LEFT
                | sequence;
    }
    private long getNextMill() {
        long mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }
    private long getNewstmp() {
        return System.currentTimeMillis();
    }
}

Snowflake 알고리즘의 장점은 ID 생성 성능이 뛰어나고 ID 길이가 짧습니다(64비트). . 데이터베이스 테이블의 기본 키로 사용할 수 있으며 정렬 및 인덱싱이 편리합니다. 그러나 클러스터의 노드 수가 머신 ID가 차지하는 자릿수를 초과하거나 클러스터가 매우 크고 타임스탬프 자릿수가 충분하지 않은 경우 다른 분산 ID 생성 알고리즘이 필요하다는 점에 유의해야 합니다. 고려됩니다.

Leaf

Leaf는 Meituan Dianping이 오픈소스로 제공하는 분산 ID 생성 알고리즘으로 전 세계적으로 고유한 64비트 ID를 생성할 수 있습니다. Leaf 알고리즘의 Java 코드는 다음과 같습니다.

Leaf 알고리즘의 Java 코드:

javaCopy code
public class LeafGenerator {
    private static final Logger logger = LoggerFactory.getLogger(LeafGenerator.class);
    private static final String WORKER_ID_KEY = "leaf.worker.id";
    private static final String PORT_KEY = "leaf.port";
    private static final int DEFAULT_PORT = 8080;
    private static final int DEFAULT_WORKER_ID = 0;
    private static final int WORKER_ID_BITS = 10;
    private static final int SEQUENCE_BITS = 12;
    private static final int MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1;
    private static final int MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1;
    private static final long EPOCH = 1514736000000L;
    private final SnowflakeIdWorker idWorker;
    public LeafGenerator() {
        int workerId = SystemPropertyUtil.getInt(WORKER_ID_KEY, DEFAULT_WORKER_ID);
        int port = SystemPropertyUtil.getInt(PORT_KEY, DEFAULT_PORT);
        this.idWorker = new SnowflakeIdWorker(workerId, port);
        logger.info("Initialized LeafGenerator with workerId={}, port={}", workerId, port);
    }
    public long nextId() {
        return idWorker.nextId();
    }
    private static class SnowflakeIdWorker {
        private final long workerId;
        private final long port;
        private long sequence = 0L;
        private long lastTimestamp = -1L;
        SnowflakeIdWorker(long workerId, long port) {
            if (workerId < 0 || workerId > MAX_WORKER_ID) {
                throw new IllegalArgumentException(String.format("workerId must be between %d and %d", 0, MAX_WORKER_ID));
            }
            this.workerId = workerId;
            this.port = port;
        }
        synchronized long nextId() {
            long timestamp = System.currentTimeMillis();
            if (timestamp < lastTimestamp) {
                throw new RuntimeException("Clock moved backwards. Refusing to generate id");
            }
            if (timestamp == lastTimestamp) {
                sequence = (sequence + 1) & MAX_SEQUENCE;
                if (sequence == 0L) {
                    timestamp = tilNextMillis(lastTimestamp);
                }
            } else {
                sequence = 0L;
            }
            lastTimestamp = timestamp;
            return ((timestamp - EPOCH) << (WORKER_ID_BITS + SEQUENCE_BITS))
                    | (workerId << SEQUENCE_BITS)
                    | sequence;
        }
        private long tilNextMillis(long lastTimestamp) {
            long timestamp = System.currentTimeMillis();
            while (timestamp <= lastTimestamp) {
                timestamp = System.currentTimeMillis();
            }
            return timestamp;
        }
    }
}

Leaf 알고리즘은 Snowflake 알고리즘보다 약간 느리게 ID를 생성하지만 더 많은 작업자 노드를 지원할 수 있습니다. Leaf 알고리즘에 의해 생성된 ID는 타임스탬프, 작업자 ID, 일련번호의 세 부분으로 구성됩니다. 타임스탬프는 42비트, 작업자 ID는 10비트, 일련번호는 12비트를 차지하여 총 64비트입니다.

위는 일반적인 분산 ID 생성 알고리즘입니다. 물론 MongoDB ID, UUID, Twitter Snowflake 등과 같은 다른 솔루션도 있습니다. 다양한 솔루션은 다양한 비즈니스 시나리오에 적합하며 구체적인 구현 세부 사항과 성능도 다릅니다. 실제 상황에 따라 적절한 솔루션을 선택해야 합니다.

위에 소개된 분산 ID 생성 알고리즘 외에도 Snowflake와 유사한 아이디어를 사용하지만 할당 방법이 다른 Flicker의 분산 ID 생성 알고리즘과 같은 몇 가지 새로운 분산 ID 생성 솔루션도 등장하고 있습니다. Snowflake보다 더 유연하며 각 부분이 차지하는 비트 수는 필요에 따라 동적으로 조정할 수 있습니다. 또한 Facebook은 ID 생성과 저장을 분리하여 보다 유연하고 확장 가능한 솔루션을 제공하지만 보다 복잡한 아키텍처 설계 및 구현이 필요한 ID 생성 서비스(IGS) 솔루션도 출시했습니다.

여러 분산 ID 생성 솔루션은 다양한 비즈니스 요구에 맞게 설계될 수 있습니다. 다음은 개인적인 제안 중 일부입니다.

• 데이터베이스 자동 증가 ID 기반 생성: 데이터베이스 자동 증가 ID를 전역 고유 ID로 사용하면 ID의 고유성을 보장할 수 있고 구현이 간단할 수 있지만 동시성이 높을 때 가능합니다. 성능 병목 현상이 발생할 수 있습니다. 따라서 동시성이 높은 시나리오에서는 사용하지 않는 것이 좋습니다.

• UUID 기반 생성: UUID를 전역적으로 고유한 ID로 사용하면 ID의 고유성을 충분히 보장할 수 있지만 ID 길이가 길어(128비트) 저장 및 전송이 편리하지 않으며 중복 가능성이 높습니다. ID는 0이 아닙니다. 분산 시스템을 사용하는 경우 ID 길이와 저장 및 전송 비용을 고려할 것을 권장합니다.

• Redis 기반 생성: Redis의 원자적 연산을 사용하여 ID의 고유성을 보장할 수 있으며, ID 생성 속도가 매우 빨라 높은 동시성 시나리오에 적용할 수 있습니다. Redis가 충돌하거나 성능이 저하되면 ID 생성 효율성과 가용성에 영향을 미칠 수 있다는 점에 유의해야 합니다.

• ZooKeeper 기반 생성: ZooKeeper의 일련번호 생성기를 사용하면 ID의 고유성을 보장할 수 있으며 구현이 비교적 간단하지만 추가 종속성과 리소스 도입이 필요하며 성능 병목 현상이 발생할 수 있습니다.

비즈니스 시나리오에 적합한 분산 ID 생성 솔루션을 선택하려면 ID 고유성, 생성 속도, 길이, 저장 비용, 확장성, 가용성 등 여러 요소를 종합적으로 고려해야 합니다. 다양한 솔루션을 구현하려면 구현 세부 사항과 성능도 다르기 때문에 실제 상황에서의 장단점과 선택을 고려해야 합니다.

각 솔루션의 자세한 코드 데모는 다음과 같습니다.

데이터베이스 자동 증가 ID를 기반으로 생성

javaCopy code
public class IdGenerator {
    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/test";
    private static final String JDBC_USER = "root";
    private static final String JDBC_PASSWORD = "password";
    public long generateId() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD);
            pstmt = conn.prepareStatement("INSERT INTO id_generator (stub) VALUES (null)", Statement.RETURN_GENERATED_KEYS);
            pstmt.executeUpdate();
            rs = pstmt.getGeneratedKeys();
            if (rs.next()) {
                return rs.getLong(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0L;
    }
}

UUID를 기반으로 생성

javaCopy code
import java.util.UUID;
public class IdGenerator {
    public String generateId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

Redis를 기반으로 생성

javaCopy code
import redis.clients.jedis.Jedis;
public class IdGenerator {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final String REDIS_PASSWORD = "password";
    private static final int ID_GENERATOR_EXPIRE_SECONDS = 3600;
    private static final String ID_GENERATOR_KEY = "id_generator";
    public long generateId() {
        Jedis jedis = null;
        try {
            jedis = new Jedis(REDIS_HOST, REDIS_PORT);
            jedis.auth(REDIS_PASSWORD);
            long id = jedis.incr(ID_GENERATOR_KEY);
            jedis.expire(ID_GENERATOR_KEY, ID_GENERATOR_EXPIRE_SECONDS);
            return id;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return 0L;
    }
}

ZooKeeper를 기반으로 생성

javaCopy code
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
public class IdGenerator implements Watcher {
    private static final String ZK_HOST = "localhost";
    private static final int ZK_PORT = 2181;
    private static final int SESSION_TIMEOUT = 5000;
    private static final String ID_GENERATOR_NODE = "/id_generator";
    private static final int ID_GENERATOR_EXPIRE_SECONDS = 3600;
    private long workerId = 0;
    public IdGenerator() {
        try {
            ZooKeeper zk = new ZooKeeper(ZK_HOST + ":" + ZK_PORT, SESSION_TIMEOUT, this);
            CountDownLatch latch = new CountDownLatch(1);
            latch.await();
            if (zk.exists(ID_GENERATOR_NODE, false) == null) {
                zk.create(ID_GENERATOR_NODE, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
            workerId = zk.getChildren(ID_GENERATOR_NODE, false).size();
            zk.create(ID_GENERATOR_NODE + "/worker_" + workerId, null, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public long generateId() {
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(ZK_HOST + ":" + ZK_PORT, SESSION_TIMEOUT, null);
            CountDownLatch latch = new CountDownLatch(1);
            latch.await();
            zk.create(ID_GENERATOR_NODE + "/id_", null, Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL, (rc, path, ctx, name) -> {}, null);
            byte[] data = zk.getData(ID_GENERATOR_NODE + "/worker_" + workerId, false, null);
            long id = Long.parseLong(new String(data)) * 10000 + zk.getChildren(ID_GENERATOR_NODE, false).size();
            return id;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (zk != null) {
                try {
                    zk.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return 0L;
    }
    @Override
    public void process(WatchedEvent event) {
        if (event.getState() == Event.KeeperState.SyncConnected) {
            System.out.println("Connected to ZooKeeper");
            CountDownLatch latch = new CountDownLatch(1);
            latch.countDown();
        }
    }
}

ZooKeeper의 여기서는 임시 노드를 사용하여 각 작업 노드를 조정합니다. 작업 노드가 죽으면 해당 임시 노드도 삭제됩니다. 이렇게 하면 각 작업 노드에서 얻은 ID가 고유해집니다.

위 내용은 Redis 분산ID 솔루션은 무엇인가요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!