跳到主要内容

16 篇博文 含有标签「开源」

查看所有标签

Zookeeper

· 阅读需 2 分钟
ahKevinXy
ahKevinXy
作者

Zookeeper 是一个针对分布式应用程序的分布式开源协调服务,分布式应用可以在这些服务的基础上构建更高级的同步,配置维护,组和命名服务

Zookeeper允许分布式进程通过共享的分层空间相互协调

中间件 提供协调服务

作用于分布式系统

支持Java 通过java和C语言的客户端api

特性​

  • 顺序一致性
  • 原子性
  • 单一视图
  • 可靠性
  • 及时性

简单的api

  • create 在树种某个位置创建节点
  • delete 删除一个节点
  • exist 测试某个位置节点状态
  • get data 获取节点数据
  • set data 将数据写入节点
  • get children 检索节点数据
  • sync 等待数据传播

介绍​

官网下载地址 :download

# 下载 bin

wget https://www.apache.org/dyn/closer.lua/zookeeper/zookeeper-3.9.1/apache-zookeeper-3.9.1-bin.tar.gz
 
 # 解压文件 
  tar -zxvf apache-zookeeper-3.9.1-bin.tar.gz 
  
  # 目录结构 
  # bin  conf  docs  lib  LICENSE.txt  logs  NOTICE.txt  README.md  README_packaging.md
  
  
 # 生成配置文件
 # 进入 conf
 
 cp zoo_sample.cfg zoo.cfg 
 
 # 进入 bin 目录
 
 # 启动 zookeeper
 ./zkServer.sh start 
 
 # zkCli.sh
 
./zkCli.sh -server 127.0.0.1:2181

zoo.cfg 配置说明​

  • tickTime 用于计算的时间单元
  • initLimit 用于集群,允许 从节点连接 并同步到master节点的初始化连接时间.以tickTime的倍数来表示
  • syncLimit 用于集群 master主节点与从节点之间发送消息,请求和应答时间长度(心跳机制)
  • dataDir 必须配置
  • dataLogDir 日志文件
  • clientPort 连接服务器的端口

雪花算法

· 阅读需 7 分钟
ahKevinXy
ahKevinXy
作者

雪花算法（Snowflake）是 Twitter 开源的分布式 ID 生成算法，核心目标是在分布式系统中生成全局唯一、趋势递增的 64 位整数 ID。它解决了传统 UUID 过长、数据库自增 ID 无法分布式部署的问题，广泛应用于微服务、分布式数据库、消息队列等场景。本文将从原理、特性、Go 实现三个维度带你掌握雪花算法。

一、雪花算法核心原理​

1. 64位ID的结构设计​

雪花算法将 64 位整数（int64）拆分为 4 个部分（不同实现的分段可能略有差异，以下是最经典的版本）：

位段位数作用
符号位1固定为 0（保证 ID 为正数）
时间戳41存储毫秒级时间戳（相对于某个起始时间），可支持约 69 年（2^41/1000/3600/24/365 ≈ 69）
机器/节点 ID10标识分布式节点（可拆分为 5 位数据中心 + 5 位机器，支持 1024 个节点）
序列号12同一毫秒内的自增序列（支持每个节点每毫秒生成 4096 个 ID）

计算验证：1 + 41 + 10 + 12 = 64，刚好占满 int64 位空间。

2. 核心特性​

  • 全局唯一：节点 ID 唯一 + 时间戳唯一 + 序列号唯一，组合保证 ID 全局不重复；
  • 趋势递增：时间戳是递增的，同一毫秒内序列号也递增，ID 整体呈递增趋势（利于数据库索引性能）；
  • 高性能：纯内存计算，无网络/数据库依赖，单机每秒可生成百万级 ID；
  • 分布式友好：节点 ID 区分不同机器/服务，支持集群部署。

3. 核心约束​

  • 时钟回拨：若节点时钟回拨，可能生成重复 ID（需特殊处理）；
  • 节点 ID 唯一：必须保证分布式环境中每个节点的 ID 不重复（否则会生成重复 ID）；
  • 起始时间固定：需提前确定算法的“纪元时间”（epoch），一旦上线不要修改。

二、Go语言实现雪花算法​

以下是一个完整、健壮的雪花算法 Go 实现，包含时钟回拨防护、并发安全、可配置节点 ID 等特性：

1. 完整实现代码​

package main

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

// Snowflake 雪花算法生成器
type Snowflake struct {
	mu        sync.Mutex // 保证并发安全
	epoch     int64      // 起始时间戳（毫秒）
	nodeID    int64      // 节点ID
	sequence  int64      // 毫秒内序列号
	lastStamp int64      // 上一次生成ID的时间戳（毫秒）

	// 位段掩码与偏移量（根据64位结构定义）
	nodeIDBits  int64 = 10                     // 节点ID位数
	sequenceBits int64 = 12                    // 序列号位数
	nodeIDMax   int64 = -1 ^ (-1 << nodeIDBits) // 节点ID最大值（1023）
	sequenceMax int64 = -1 ^ (-1 << sequenceBits) // 序列号最大值（4095）

	nodeIDShift  int64 = sequenceBits          // 节点ID偏移量
	timeStampShift int64 = sequenceBits + nodeIDBits // 时间戳偏移量
}

// NewSnowflake 创建雪花算法实例
// epoch: 起始时间戳（毫秒），如 1704067200000（2024-01-01 00:00:00）
// nodeID: 节点ID（0-1023）
func NewSnowflake(epoch int64, nodeID int64) (*Snowflake, error) {
	// 校验节点ID范围
	if nodeID < 0 || nodeID > (-1 ^ (-1 << 10)) {
		return nil, errors.New("node ID must be between 0 and 1023")
	}

	return &Snowflake{
		epoch:     epoch,
		nodeID:    nodeID,
		sequence:  0,
		lastStamp: -1,
	}, nil
}

// 获取当前毫秒级时间戳
func (s *Snowflake) now() int64 {
	return time.Now().UnixMilli()
}

// NextID 生成下一个唯一ID
func (s *Snowflake) NextID() (int64, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	// 1. 获取当前时间戳
	now := s.now()

	// 2. 处理时钟回拨
	if now < s.lastStamp {
		return 0, fmt.Errorf("clock moved backwards. Refusing to generate ID for %d milliseconds", s.lastStamp-now)
	}

	// 3. 同一毫秒内，序列号自增
	if now == s.lastStamp {
		s.sequence = (s.sequence + 1) & s.sequenceMax
		// 序列号溢出（同一毫秒生成超过4096个ID）
		if s.sequence == 0 {
			// 等待到下一毫秒
			for now <= s.lastStamp {
				now = s.now()
			}
		}
	} else {
		// 不同毫秒，重置序列号
		s.sequence = 0
	}

	// 4. 更新上一次时间戳
	s.lastStamp = now

	// 5. 组合64位ID
	// 时间戳部分：(now - epoch) << 22
	// 节点ID部分：nodeID << 12
	// 序列号部分：sequence
	id := ((now - s.epoch) << s.timeStampShift) | (s.nodeID << s.nodeIDShift) | s.sequence

	return id, nil
}

// 测试示例
func main() {
	// 自定义起始时间（2024-01-01 00:00:00）
	epoch := int64(1704067200000)
	// 节点ID（假设当前节点为1）
	nodeID := int64(1)

	// 创建雪花算法实例
	sf, err := NewSnowflake(epoch, nodeID)
	if err != nil {
		panic(err)
	}

	// 并发生成10个ID测试
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(idx int) {
			defer wg.Done()
			id, err := sf.NextID()
			if err != nil {
				fmt.Printf("生成ID失败：%v\n", err)
				return
			}
			fmt.Printf("第%d个ID：%d\n", idx+1, id)
		}(i)
	}
	wg.Wait()
}

2. 代码关键部分解释​

（1）结构体字段​

  • mu：互斥锁，保证多 goroutine 下生成 ID 的并发安全；
  • epoch：算法的起始时间戳（自定义，建议设置为项目上线时间），减少时间戳占用的位数；
  • nodeID：节点唯一标识，需在分布式环境中提前分配（如 0-1023）；
  • lastStamp：上一次生成 ID 的时间戳，用于检测时钟回拨和同一毫秒的序列号递增；
  • 位段相关常量：定义节点 ID、序列号的位数和最大值，避免越界。

（2）NextID 核心逻辑​

  1. 加锁：保证并发安全，避免同一毫秒内序列号重复；
  2. 时钟回拨检测：若当前时间戳小于上一次的时间戳，直接返回错误（防止重复 ID）；
  3. 序列号处理：
    • 同一毫秒：序列号自增，若溢出则等待到下一毫秒；
    • 不同毫秒：重置序列号为 0；
  4. 组合 ID：将“相对时间戳 + 节点 ID + 序列号”按位偏移组合成 64 位整数。

（3）测试示例​

  • 自定义起始时间为 2024-01-01 00:00:00，节点 ID 为 1；
  • 并发生成 10 个 ID，验证算法的并发安全性和唯一性。

3. 运行结果示例​

第1个ID：1234567890123456789
第2个ID：1234567890123456790
第3个ID：1234567890123456791
...
第10个ID：1234567890123456798

三、进阶优化与注意事项​

1. 时钟回拨优化​

上述实现中，时钟回拨直接返回错误，实际生产中可优化为：

  • 短暂等待（如 10ms），若时钟恢复正常则继续生成；
  • 记录时钟回拨日志，触发告警，人工介入处理；
  • 预留备用节点 ID，时钟回拨时临时切换节点 ID（避免重复）。

2. 节点 ID 分配策略​

分布式环境中，节点 ID 需保证唯一，常见分配方式：

  • 配置文件手动指定（适合小规模集群）；
  • 从配置中心（如 Etcd、Nacos）获取（适合大规模集群）；
  • 基于机器 IP/端口计算（如 IP 最后 10 位作为节点 ID）。

3. 性能优化​

  • 减少锁竞争：若单机并发极高，可拆分多个雪花算法实例（不同节点 ID），降低单个锁的竞争；
  • 预生成 ID：提前生成一批 ID 存入缓冲区，减少实时生成的锁等待。

4. 适用场景​

✅ 适合：分布式系统全局唯一 ID、订单号、日志 ID、消息 ID 等； ❌ 不适合：需要严格连续的 ID（雪花算法是趋势递增，非严格连续）、需要跨系统长期兼容的 ID（若修改 epoch 或节点 ID 规则会导致 ID 重复）。

四、与其他 ID 生成方案对比​

方案优点缺点
雪花算法高性能、全局唯一、趋势递增依赖时钟、节点 ID 需唯一、时钟回拨风险
UUID无需配置、完全唯一过长（128位）、无序、不利于索引
数据库自增 ID简单、严格递增分布式部署困难、性能瓶颈

总结​

  1. 雪花算法的核心是将 64 位 int64 拆分为“符号位+时间戳+节点 ID+序列号”，保证分布式环境下 ID 全局唯一且趋势递增；
  2. Go 实现需重点处理并发安全（互斥锁）和时钟回拨（防止重复 ID），节点 ID 需保证分布式唯一；
  3. 实际使用中可根据业务场景优化时钟回拨处理、节点 ID 分配策略，兼顾性能和可靠性。

Electron 入门

· 阅读需 3 分钟
ahKevinXy
ahKevinXy
作者

Electron是由Github开发的开源框架，它允许开发者使用Web技术构建跨平台的桌面应用。Electron=Chromium+Node.js+Native API，其中Chromium为Electron提供了强大的UI能力，可以不考虑兼容性的情况下，利用强大的Web生态来开发界面；Native API让Electron有了跨平台和桌面端的原生能力，比如说它有统一的原生界面，窗口、托盘这些