40分钟学 Go 语言高并发：【实战】分布式缓存系统

news2024/12/26 19:27:02

【实战课程】分布式缓存系统

一、整体架构设计

首先，让我们通过架构图了解分布式缓存系统的整体设计：
在这里插入图片描述

核心组件

组件名称功能描述技术选型
负载均衡层请求分发、节点选择一致性哈希
缓存节点数据存储、过期处理内存存储 + 持久化
同步机制节点间数据同步Pub/Sub + Gossip
监控系统性能监控、故障检测Prometheus + Grafana

二、核心代码实现

1. 缓存节点实现

package dcache

import (
    "context"
    "encoding/json"
    "sync"
    "time"
)

// CacheItem 缓存项结构
type CacheItem struct {
    Value      interface{} `json:"value"`
    Expiration int64      `json:"expiration"`
    CreatedAt  int64      `json:"created_at"`
    UpdatedAt  int64      `json:"updated_at"`
}

// CacheNode 缓存节点结构
type CacheNode struct {
    nodeID    string
    items     sync.Map
    peers     map[string]*CacheNode
    peerLock  sync.RWMutex
    options   *Options
}

// Options 配置选项
type Options struct {
    DefaultExpiration time.Duration
    CleanupInterval  time.Duration
    MaxItems        int
}

// NewCacheNode 创建新的缓存节点
func NewCacheNode(nodeID string, opts *Options) *CacheNode {
    node := &CacheNode{
        nodeID: nodeID,
        peers:  make(map[string]*CacheNode),
        options: opts,
    }

    // 启动清理过期项的定时任务
    if opts.CleanupInterval > 0 {
        go node.cleanupLoop()
    }

    return node
}

// Set 设置缓存项
func (n *CacheNode) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
    item := &CacheItem{
        Value:      value,
        CreatedAt:  time.Now().UnixNano(),
        UpdatedAt:  time.Now().UnixNano(),
    }

    if expiration == 0 {
        expiration = n.options.DefaultExpiration
    }

    if expiration > 0 {
        item.Expiration = time.Now().Add(expiration).UnixNano()
    }

    n.items.Store(key, item)
    
    // 通知其他节点更新
    n.notifyPeers(ctx, key, item)
    
    return nil
}

// Get 获取缓存项
func (n *CacheNode) Get(ctx context.Context, key string) (interface{}, bool) {
    if value, exists := n.items.Load(key); exists {
        item := value.(*CacheItem)
        if item.Expiration > 0 && item.Expiration < time.Now().UnixNano() {
            n.items.Delete(key)
            return nil, false
        }
        return item.Value, true
    }
    return nil, false
}

// Delete 删除缓存项
func (n *CacheNode) Delete(ctx context.Context, key string) {
    n.items.Delete(key)
    // 通知其他节点删除
    n.notifyPeersDelete(ctx, key)
}

// cleanupLoop 清理过期项的循环
func (n *CacheNode) cleanupLoop() {
    ticker := time.NewTicker(n.options.CleanupInterval)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            n.cleanup()
        }
    }
}

// cleanup 清理过期项
func (n *CacheNode) cleanup() {
    now := time.Now().UnixNano()
    n.items.Range(func(key, value interface{}) bool {
        item := value.(*CacheItem)
        if item.Expiration > 0 && item.Expiration < now {
            n.items.Delete(key)
        }
        return true
    })
}

// AddPeer 添加对等节点
func (n *CacheNode) AddPeer(peer *CacheNode) {
    n.peerLock.Lock()
    defer n.peerLock.Unlock()
    n.peers[peer.nodeID] = peer
}

// RemovePeer 移除对等节点
func (n *CacheNode) RemovePeer(peerID string) {
    n.peerLock.Lock()
    defer n.peerLock.Unlock()
    delete(n.peers, peerID)
}

// notifyPeers 通知其他节点更新
func (n *CacheNode) notifyPeers(ctx context.Context, key string, item *CacheItem) {
    n.peerLock.RLock()
    defer n.peerLock.RUnlock()
    
    for _, peer := range n.peers {
        go func(p *CacheNode) {
            p.receiveUpdate(ctx, key, item)
        }(peer)
    }
}

// receiveUpdate 接收更新通知
func (n *CacheNode) receiveUpdate(ctx context.Context, key string, item *CacheItem) {
    n.items.Store(key, item)
}

2. 一致性哈希实现

package dcache

import (
    "hash/crc32"
    "sort"
    "sync"
)

type ConsistentHash struct {
    circle       map[uint32]string
    sortedHashes []uint32
    nodes        map[string]bool
    virtualNodes int
    mu           sync.RWMutex
}

func NewConsistentHash(virtualNodes int) *ConsistentHash {
    return &ConsistentHash{
        circle:       make(map[uint32]string),
        nodes:        make(map[string]bool),
        virtualNodes: virtualNodes,
    }
}

// Add 添加节点
func (c *ConsistentHash) Add(node string) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if _, exists := c.nodes[node]; exists {
        return
    }

    c.nodes[node] = true

    for i := 0; i < c.virtualNodes; i++ {
        hash := c.hashKey(fmt.Sprintf("%s-%d", node, i))
        c.circle[hash] = node
    }

    c.updateSortedHashes()
}

// Remove 移除节点
func (c *ConsistentHash) Remove(node string) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if _, exists := c.nodes[node]; !exists {
        return
    }

    delete(c.nodes, node)

    for i := 0; i < c.virtualNodes; i++ {
        hash := c.hashKey(fmt.Sprintf("%s-%d", node, i))
        delete(c.circle, hash)
    }

    c.updateSortedHashes()
}

// Get 获取负责的节点
func (c *ConsistentHash) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()

    if len(c.circle) == 0 {
        return ""
    }

    hash := c.hashKey(key)
    idx := c.searchForNode(hash)

    return c.circle[c.sortedHashes[idx]]
}

// hashKey 计算哈希值
func (c *ConsistentHash) hashKey(key string) uint32 {
    return crc32.ChecksumIEEE([]byte(key))
}

// updateSortedHashes 更新已排序的哈希值切片
func (c *ConsistentHash) updateSortedHashes() {
    hashes := make([]uint32, 0, len(c.circle))
    for k := range c.circle {
        hashes = append(hashes, k)
    }
    sort.Slice(hashes, func(i, j int) bool {
        return hashes[i] < hashes[j]
    })
    c.sortedHashes = hashes
}

// searchForNode 查找适合的节点
func (c *ConsistentHash) searchForNode(hash uint32) int {
    idx := sort.Search(len(c.sortedHashes), func(i int) bool {
        return c.sortedHashes[i] >= hash
    })

    if idx >= len(c.sortedHashes) {
        idx = 0
    }

    return idx
}

3. 数据同步流程图

在这里插入图片描述

4. 故障恢复实现

package dcache

import (
    "context"
    "sync"
    "time"
)

type FailureDetector struct {
    nodes       map[string]*NodeStatus
    mu          sync.RWMutex
    checkInterval time.Duration
    timeout       time.Duration
}

type NodeStatus struct {
    LastHeartbeat time.Time
    IsAlive       bool
    Address       string
}

func NewFailureDetector(checkInterval, timeout time.Duration) *FailureDetector {
    fd := &FailureDetector{
        nodes:         make(map[string]*NodeStatus),
        checkInterval: checkInterval,
        timeout:       timeout,
    }
    go fd.startDetection()
    return fd
}

// RegisterNode 注册节点
func (fd *FailureDetector) RegisterNode(nodeID, address string) {
    fd.mu.Lock()
    defer fd.mu.Unlock()
    
    fd.nodes[nodeID] = &NodeStatus{
        LastHeartbeat: time.Now(),
        IsAlive:       true,
        Address:       address,
    }
}

// UpdateHeartbeat 更新心跳
func (fd *FailureDetector) UpdateHeartbeat(nodeID string) {
    fd.mu.Lock()
    defer fd.mu.Unlock()
    
    if node, exists := fd.nodes[nodeID]; exists {
        node.LastHeartbeat = time.Now()
        node.IsAlive = true
    }
}

// startDetection 开始故障检测
func (fd *FailureDetector) startDetection() {
    ticker := time.NewTicker(fd.checkInterval)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            fd.detectFailures()
        }
    }
}

// detectFailures 检测故障
func (fd *FailureDetector) detectFailures() {
    fd.mu.Lock()
    defer fd.mu.Unlock()
    
    now := time.Now()
    for nodeID, status := range fd.nodes {
        if status.IsAlive && now.Sub(status.LastHeartbeat) > fd.timeout {
            status.IsAlive = false
            go fd.handleNodeFailure(nodeID)
        }
    }
}

// handleNodeFailure 处理节点故障
func (fd *FailureDetector) handleNodeFailure(nodeID string) {
    // 1. 通知其他节点
    fd.notifyPeers(nodeID)
    
    // 2. 触发数据重平衡
    fd.rebalanceData(nodeID)
}

// notifyPeers 通知其他节点
func (fd *FailureDetector) notifyPeers(failedNodeID string) {
    fd.mu.RLock()
    defer fd.mu.RUnlock()

    for nodeID, status := range fd.nodes {
        if nodeID != failedNodeID && status.IsAlive {
            go fd.sendFailureNotification(status.Address, failedNodeID)
        }
    }
}

// sendFailureNotification 发送故障通知
func (fd *FailureDetector) sendFailureNotification(address, failedNodeID string) {
    // 实现具体的通知逻辑
    // 可以使用HTTP或gRPC等方式
}

// rebalanceData 重平衡数据
func (fd *FailureDetector) rebalanceData(failedNodeID string) {
    // 1. 确定需要迁移的数据
    // 2. 选择目标节点
    // 3. 执行数据迁移
    fd.mu.RLock()
    defer fd.mu.RUnlock()

    var aliveNodes []string
    for nodeID, status := range fd.nodes {
        if status.IsAlive && nodeID != failedNodeID {
            aliveNodes = append(aliveNodes, nodeID)
        }
    }

    if len(aliveNodes) == 0 {
        return
    }

    // 触发数据迁移
    go fd.migrateData(failedNodeID, aliveNodes)
}

// migrateData 迁移数据
func (fd *FailureDetector) migrateData(failedNodeID string, aliveNodes []string) {
    // 实现数据迁移逻辑
}

// IsNodeAlive 检查节点是否存活
func (fd *FailureDetector) IsNodeAlive(nodeID string) bool {
    fd.mu.RLock()
    defer fd.mu.RUnlock()
    
    if status, exists := fd.nodes[nodeID]; exists {
        return status.IsAlive
    }
    return false
}

// GetAliveNodes 获取所有存活节点
func (fd *FailureDetector) GetAliveNodes() []string {
    fd.mu.RLock()
    defer fd.mu.RUnlock()
    
    var aliveNodes []string
    for nodeID, status := range fd.nodes {
        if status.IsAlive {
            aliveNodes = append(aliveNodes, nodeID)
        }
    }
    return aliveNodes
}

三、缓存同步机制

1. 同步策略比较

策略优点缺点适用场景
同步复制强一致性性能较差对一致性要求高的场景
异步复制性能好最终一致性对性能要求高的场景
半同步复制折中方案实现复杂平衡性能和一致性

2. 数据同步实现

package dcache

import (
    "context"
    "encoding/json"
    "sync"
    "time"
)

type SyncManager struct {
    node         *CacheNode
    syncInterval time.Duration
    syncTimeout  time.Duration
    syncQueue    chan *SyncTask
    wg           sync.WaitGroup
}

type SyncTask struct {
    Key       string
    Value     interface{}
    Operation string // "set" or "delete"
    Timestamp int64
}

func NewSyncManager(node *CacheNode, syncInterval, syncTimeout time.Duration) *SyncManager {
    sm := &SyncManager{
        node:         node,
        syncInterval: syncInterval,
        syncTimeout:  syncTimeout,
        syncQueue:    make(chan *SyncTask, 1000),
    }
    
    go sm.processSyncQueue()
    return sm
}

// AddSyncTask 添加同步任务
func (sm *SyncManager) AddSyncTask(task *SyncTask) {
    select {
    case sm.syncQueue <- task:
        // 成功添加到队列
    default:
        // 队列已满，记录错误日志
    }
}

// processSyncQueue 处理同步队列
func (sm *SyncManager) processSyncQueue() {
    ticker := time.NewTicker(sm.syncInterval)
    defer ticker.Stop()

    var tasks []*SyncTask
    
    for {
        select {
        case task := <-sm.syncQueue:
            tasks = append(tasks, task)
            
            // 批量处理
            if len(tasks) >= 100 {
                sm.processBatch(tasks)
                tasks = tasks[:0]
            }
            
        case <-ticker.C:
            if len(tasks) > 0 {
                sm.processBatch(tasks)
                tasks = tasks[:0]
            }
        }
    }
}

// processBatch 批量处理同步任务
func (sm *SyncManager) processBatch(tasks []*SyncTask) {
    ctx, cancel := context.WithTimeout(context.Background(), sm.syncTimeout)
    defer cancel()

    // 按节点分组任务
    tasksByNode := make(map[string][]*SyncTask)
    for _, task := range tasks {
        // 使用一致性哈希确定目标节点
        node := sm.node.hashRing.Get(task.Key)
        tasksByNode[node] = append(tasksByNode[node], task)
    }

    // 并发同步到各节点
    var wg sync.WaitGroup
    for node, nodeTasks := range tasksByNode {
        wg.Add(1)
        go func(node string, tasks []*SyncTask) {
            defer wg.Done()
            sm.syncToNode(ctx, node, tasks)
        }(node, nodeTasks)
    }
    wg.Wait()
}

// syncToNode 同步到指定节点
func (sm *SyncManager) syncToNode(ctx context.Context, nodeID string, tasks []*SyncTask) {
    // 1. 建立连接
    conn, err := sm.getNodeConnection(nodeID)
    if err != nil {
        return
    }
    
    // 2. 发送同步数据
    for _, task := range tasks {
        switch task.Operation {
        case "set":
            conn.Set(ctx, task.Key, task.Value, 0)
        case "delete":
            conn.Delete(ctx, task.Key)
        }
    }
}

// getNodeConnection 获取节点连接
func (sm *SyncManager) getNodeConnection(nodeID string) (*CacheNode, error) {
    // 实现节点连接池逻辑
    return nil, nil
}

// StartFullSync 启动全量同步
func (sm *SyncManager) StartFullSync() {
    sm.wg.Add(1)
    go func() {
        defer sm.wg.Done()
        sm.fullSync()
    }()
}

// fullSync 全量同步
func (sm *SyncManager) fullSync() {
    // 1. 获取源节点数据快照
    snapshot := sm.node.GetSnapshot()
    
    // 2. 同步到目标节点
    for key, value := range snapshot {
        task := &SyncTask{
            Key:       key,
            Value:     value,
            Operation: "set",
            Timestamp: time.Now().UnixNano(),
        }
        sm.AddSyncTask(task)
    }
}

// WaitForSync 等待同步完成
func (sm *SyncManager) WaitForSync() {
    sm.wg.Wait()
}

四、监控指标

1. 核心监控指标

type Metrics struct {
    // 缓存命中率
    HitCount    int64
    MissCount   int64
    HitRate     float64

    // 容量指标
    ItemCount   int64
    MemoryUsage int64
    
    // 性能指标
    AvgLatency     float64
    P95Latency     float64
    P99Latency     float64
    
    // 同步指标
    SyncQueueSize  int64
    SyncLatency    float64
    SyncErrorCount int64
}

2. 监控指标表

指标类型指标名称说明告警阈值
性能指标avgLatency平均响应延迟>50ms
性能指标p95Latency95分位延迟>100ms
性能指标p99Latency99分位延迟>200ms
命中率hitRate缓存命中率<80%
容量指标memoryUsage内存使用率>80%
同步指标syncQueueSize同步队列大小>1000
同步指标syncLatency同步延迟>1s
错误指标errorCount错误次数>100/min

五、优化建议

1. 性能优化

  1. 使用内存预分配
  2. 采用批量操作
  3. 实现多级缓存
  4. 使用零拷贝技术

2. 可靠性优化

  1. 实现故障自动转移
  2. 添加熔断机制
  3. 实现请求重试
  4. 数据定期备份

3. 监控优化

  1. 实现多维度监控
  2. 添加实时告警
  3. 收集详细日志
  4. 定期压测验证

六、实战建议

  1. 开发阶段：

    • 充分测试各个组件
    • 模拟各种故障场景
    • 进行性能基准测试
    • 编写完善的单元测试

  2. 部署阶段：

    • 合理规划节点部署
    • 配置监控告警
    • 准备回滚方案
    • 进行容量规划

  3. 运维阶段：

    • 定期检查监控指标
    • 及时处理告警信息
    • 定期进行压力测试
    • 制定应急预案

七、实战练习

  1. 基础练习：

    • 实现简单的缓存节点
    • 实现基本的数据同步
    • 添加简单的监控指标

  2. 进阶练习：

    • 实现完整的故障检测
    • 实现数据自动迁移
    • 实现多级缓存策略

  3. 高级练习：

    • 优化同步性能
    • 实现数据压缩
    • 实现缓存预热

怎么样今天的内容还满意吗？再次感谢观众老爷的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2254353.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

w~视觉~合集27

w~视觉~合集27

我自己的原文哦~ https://blog.51cto.com/whaosoft/12715639 #视频AIGC~论文 1、Pix2Video: Video Editing using Image Diffusion 基于大规模图像库训练的图像扩散模型已成为质量和多样性方面最为通用的图像生成模型。它们支持反转真实图像和条件生成&#xff08;例如&…
阅读更多...
MYSQL中的增删改查操作（如果想知道MYSQL中有关增删改查操作的知识，那么只看这一篇就足够了！）

MYSQL中的增删改查操作（如果想知道MYSQL中有关增删改查操作的知识，那么只看这一篇就足够了！）

前言&#xff1a;在 MySQL 中&#xff0c;增、删、改、查&#xff08;CRUD&#xff09;操作是基本的数据库操作&#xff0c;增操作&#xff08;INSERT&#xff09;用于插入数据&#xff0c;删操作&#xff08;DELETE&#xff09;用于删除数据&#xff0c;改操作&#xff08;UPD…
阅读更多...
Ansible的yum和saltstack的哪个功能相似

Ansible的yum和saltstack的哪个功能相似

Ansible的yum和saltstack的哪个功能相似 在 Ansible 和 SaltStack 中&#xff0c;Ansible 的 yum 模块 和 SaltStack 的 pkg 模块 功能相似。它们都用于管理软件包&#xff0c;支持安装、升级、删除和查询等操作。 Ansible 的 yum 模块 用途&#xff1a; 专门用于基于 Red Hat …
阅读更多...
在做题中学习（76）：颜色分类

在做题中学习（76）：颜色分类

解法&#xff1a;三指针 思路&#xff1a;用三个指针&#xff0c;把数组划分为三个区域&#xff1a; for循环遍历数组&#xff0c;i遍历数组&#xff0c;left是0区间的末尾&#xff0c;right是2区间的开头&#xff0c;0 1 2区间成功被划分 而上面的图画是最终实现的图样&…
阅读更多...
Java版-速通数据结构-树基础知识

Java版-速通数据结构-树基础知识

现在面试问mysql,红黑树好像都是必备问题了。动不动就让手写红黑树或者简单介绍下红黑树。然而&#xff0c;我们如果直接去看红黑树&#xff0c;可能会一下子蒙了。在看红黑树之前&#xff0c;需要先了解下树的基础知识&#xff0c;从简单到复杂&#xff0c;看看红黑树是在什么…
阅读更多...
浙江工业大学《2024年828自动控制原理真题》 (完整版）

浙江工业大学《2024年828自动控制原理真题》 (完整版）

本文内容&#xff0c;全部选自自动化考研联盟的&#xff1a;《浙江工业大学828自控考研资料》的真题篇。后续会持续更新更多学校&#xff0c;更多年份的真题&#xff0c;记得关注哦~ 目录 2024年真题 Part1&#xff1a;2024年完整版真题 2024年真题
阅读更多...
【计算机网络】实验11：边界网关协议BGP

【计算机网络】实验11：边界网关协议BGP

实验11 边界网关协议BGP 一、实验目的 本次实验旨在验证边界网关协议&#xff08;BGP&#xff09;的实际作用&#xff0c;并深入学习在路由器上配置和使用BGP协议的方法。通过实验&#xff0c;我将探索BGP在不同自治系统之间的路由选择和信息交换的功能&#xff0c;理解其在互…
阅读更多...
微信小程序全屏显示地图

微信小程序全屏显示地图

微信小程序在界面上显示地图&#xff0c;只需要用map标签 <map longitude"经度度数" latitude"纬度度数"></map>例如北京的经纬度为&#xff1a;116.407004,39.904595 <map class"bgMap" longitude"116.407004" lati…
阅读更多...
InfluxDB 集成 Grafana

InfluxDB 集成 Grafana

将InfluxDB集成到Grafana进行详细配置通常包括以下几个步骤&#xff1a;安装与配置InfluxDB、安装与配置Grafana、在Grafana中添加InfluxDB数据源以及创建和配置仪表板。以下是一个详细的配置指南&#xff1a; 一、安装与配置InfluxDB 下载与安装&#xff1a; 从InfluxDB的官…
阅读更多...
【AI系统】ESPNet 系列

【AI系统】ESPNet 系列

ESPNet 系列 本文将会介绍 ESPNet 系列&#xff0c;该网络主要应用在高分辨率图像下的语义分割&#xff0c;在计算内存占用、功耗方面都非常高效&#xff0c;重点介绍一种高效的空间金字塔卷积模块&#xff08;ESP Module&#xff09;&#xff1b;而在 ESPNet V2 上则是会更进…
阅读更多...
【Axios】如何在Vue中使用Axios请求拦截器

【Axios】如何在Vue中使用Axios请求拦截器

✨✨ 欢迎大家来到景天科技苑✨✨ &#x1f388;&#x1f388; 养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; &#x1f3c6; 作者简介&#xff1a;景天科技苑 &#x1f3c6;《头衔》&#xff1a;大厂架构师&#xff0c;华为云开发者社区专家博主&#xff0c;…
阅读更多...
w~深度学习~合集1

w~深度学习~合集1

我自己的原文哦~ https://blog.51cto.com/whaosoft/12663254 #Motion Plan 代码 github.com/liangwq/robot_motion_planing 轨迹约束中的软硬约束 前面的几篇文章已经介绍了&#xff0c;轨迹约束的本质就是在做带约束的轨迹拟合。输入就是waypoint点list&#xff0c;约束…
阅读更多...
大语言模型应用开发框架LangChain

大语言模型应用开发框架LangChain

大语言模型应用开发框架LangChain 一、LangChain项目介绍1、简介2、LangChain的价值3、实战演练 二、LangChain提示词大语言模型应用1、简介1.1、提示词模板化的优点1.2、提示词模板LLM 的应用1.3、Prompt 2、应用实战2.1、PromptTemplate LLM2.2、PromptTemplate LLM Outpu…
阅读更多...
公众号文章标题的重要性

公众号文章标题的重要性

标题&#xff0c;不仅仅是一个简单的标题&#xff0c;它更是吸引读者眼球的“颜值担当”。 信息爆炸的今天&#xff0c;一个好的标题就是打开流量之门的金钥匙。那么&#xff0c;如何衡量一个标题的“颜值”呢&#xff1f;我们可以从两个维度来看&#xff1a;打开率和传播率。…
阅读更多...
116. UE5 GAS RPG 实现击杀掉落战利品功能

116. UE5 GAS RPG 实现击杀掉落战利品功能

这一篇&#xff0c;我们实现敌人被击败后&#xff0c;掉落战利品的功能。首先&#xff0c;我们将创建一个新的结构体&#xff0c;用于定义掉落体的内容&#xff0c;方便我们设置掉落物。然后&#xff0c;我们实现敌人死亡时的掉落函数&#xff0c;并在蓝图里实现对应的逻辑&…
阅读更多...
ros2人脸检测

ros2人脸检测

第一步&#xff1a; 首先在工作空间/src下创建数据结构目录service_interfaces ros2 pkg create service_interfaces --build-type ament_cmake 然后再创建一个srv目录 在里面创建FaceDetect.srv&#xff08;注意&#xff0c;首字母要大写&#xff09; sensor_msgs/Image …
阅读更多...
Neo4j：图数据库使用入门

Neo4j：图数据库使用入门

文章目录 一、Neo4j安装1、windows安装&#xff08;1&#xff09;准备环境&#xff08;2&#xff09;下载&#xff08;3&#xff09;解压&#xff08;4&#xff09;运行&#xff08;5&#xff09;基本使用 2、docker安装 二、CQL语句1、CQL简介2、CREATE 命令&#xff0c;创建节…
阅读更多...
五.指派问题

五.指派问题

匈牙利发求解指派问题找独立0元素&#xff0c;常用的步骤为&#xff1a;
阅读更多...
如何利用AI生成专业级海报教程：解决中文嵌入问题的实战指南

如何利用AI生成专业级海报教程：解决中文嵌入问题的实战指南

AI生成专业级海报教程：解决中文嵌入问题的实战指南 一、前言：突破性进展 重大突破！字节即梦AI最新发布的v2.1绘图模型完美解决了中文文字嵌入问题。等待了整整两年，我们终于等到了这一天 —— AI可以直接在图片上完美呈现中文字体，审美和泛化能力都达到了惊人的水平。 二…
阅读更多...
优质翻译在美国电子游戏推广中的作用

优质翻译在美国电子游戏推广中的作用

美国作为世界上最大的视频游戏市场之一&#xff0c;为寻求全球成功的游戏开发商提供了无与伦比的机会。然而&#xff0c;美国市场的文化和语言多样性使其成为一个复杂的导航景观。高质量的翻译在弥合开发者和这些充满活力的观众之间的差距方面发挥着关键作用&#xff0c;确保游…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023