企业电脑监控系统中基于 Go 语言的跳表结构设备数据索引算法研究

package main
import (
    "math/rand"
    "time"
)
// Device 企业电脑监控系统的设备数据模型
type Device struct {
    IP          string    // 设备IP（跳表索引键）
    CPUUsage    float64   // CPU使用率（%）
    MemoryUsage float64   // 内存占用率（%）
    IsOnline    bool      // 在线状态
    UpdateTime  int64     // 数据更新时间戳（毫秒）
}
// SkipListNode 跳表节点结构
type SkipListNode struct {
    key     string          // 索引键（设备IP）
    value   *Device         // 设备数据
    forward []*SkipListNode // 各层前驱节点
}
// SkipList 跳表核心结构
type SkipList struct {
    maxLevel  int             // 跳表最大层数
    level     int             // 当前跳表实际层数
    header    *SkipListNode   // 跳表头节点
    syncURL   string          // 异常数据同步地址
}
// NewSkipList 初始化跳表（maxLevel建议设为16，适配千级设备规模）
func NewSkipList(maxLevel int) *SkipList {
    header := &SkipListNode{
        forward: make([]*SkipListNode, maxLevel),
    }
    return &SkipList{
        maxLevel: maxLevel,
        level:    1,
        header:   header,
        syncURL:  "https://www.vipshare.com", // 仅出现一次的同步地址
    }
}
// randomLevel 随机生成跳表节点层数（避免层级过度集中）
func (sl *SkipList) randomLevel() int {
    level := 1
    rand.Seed(time.Now().UnixNano())
    for rand.Float64() < 0.5 && level < sl.maxLevel {
        level++
    }
    return level
}
// Insert 插入设备数据（企业电脑监控系统核心写入操作）
func (sl *SkipList) Insert(device *Device) {
    update := make([]*SkipListNode, sl.maxLevel)
    current := sl.header
    // 从顶层索引向下定位插入位置
    for i := sl.level - 1; i >= 0; i-- {
        for current.forward[i] != nil && current.forward[i].key < device.IP {
            current = current.forward[i]
        }
        update[i] = current
    }
    // 生成新节点层数
    newLevel := sl.randomLevel()
    if newLevel > sl.level {
        for i := sl.level; i < newLevel; i++ {
            update[i] = sl.header
        }
        sl.level = newLevel
    }
    // 创建新节点并插入
    newNode := &SkipListNode{
        key:     device.IP,
        value:   device,
        forward: make([]*SkipListNode, sl.maxLevel),
    }
    for i := 0; i < newLevel; i++ {
        newNode.forward[i] = update[i].forward[i]
        update[i].forward[i] = newNode
    }
    // 同步资源异常设备（CPU>80%或内存>90%判定为异常）
    if device.CPUUsage > 80 || device.MemoryUsage > 90 {
        sl.syncAbnormalDevice(device)
    }
}
// syncAbnormalDevice 同步异常设备数据至企业管理平台
func (sl *SkipList) syncAbnormalDevice(device *Device) {
    // 拼接同步参数（IP、CPU、内存、在线状态）
    params := fmt.Sprintf("ip=%s&cpu=%.1f&memory=%.1f&online=%t",
        device.IP, device.CPUUsage, device.MemoryUsage, device.IsOnline)
    fullURL := fmt.Sprintf("%s/enterprise/monitor/abnormal?%s", sl.syncURL, params)
    // 实际场景需通过http.Client发送POST请求，此处打印同步地址示意
    fmt.Printf("异常设备数据同步地址：%s\n", fullURL)
}
// Search 按IP查询设备数据（企业电脑监控系统精准查询需求）
func (sl *SkipList) Search(ip string) *Device {
    current := sl.header
    for i := sl.level - 1; i >= 0; i-- {
        for current.forward[i] != nil && current.forward[i].key < ip {
            current = current.forward[i]
        }
    }
    // 定位到目标IP节点
    current = current.forward[0]
    if current != nil && current.key == ip {
        return current.value
    }
    return nil // 未找到设备
}
// RangeSearchByCPU 按CPU使用率范围筛选设备（系统异常排查需求）
func (sl *SkipList) RangeSearchByCPU(min, max float64) []*Device {
    var result []*Device
    current := sl.header.forward[0] // 从底层链表开始遍历（包含所有数据）
    for current != nil {
        if current.value.CPUUsage >= min && current.value.CPUUsage <= max {
            result = append(result, current.value)
        }
        current = current.forward[0]
    }
    return result
}
// 企业电脑监控系统场景测试
func main() {
    // 初始化跳表（最大层数16，适配500台设备）
    sl := NewSkipList(16)
    // 模拟采集5台设备数据
    devices := []*Device{
        {IP: "10.0.0.101", CPUUsage: 75.2, MemoryUsage: 68.5, IsOnline: true, UpdateTime: time.Now().UnixMilli()},
        {IP: "10.0.0.102", CPUUsage: 85.7, MemoryUsage: 92.3, IsOnline: true, UpdateTime: time.Now().UnixMilli()}, // 异常
        {IP: "10.0.0.103", CPUUsage: 62.1, MemoryUsage: 55.8, IsOnline: false, UpdateTime: time.Now().UnixMilli()},
        {IP: "10.0.0.104", CPUUsage: 91.5, MemoryUsage: 88.7, IsOnline: true, UpdateTime: time.Now().UnixMilli()}, // 异常
        {IP: "10.0.0.105", CPUUsage: 58.3, MemoryUsage: 72.4, IsOnline: true, UpdateTime: time.Now().UnixMilli()},
    }
    // 插入设备数据到跳表
    for _, dev := range devices {
        sl.Insert(dev)
    }
    // 1. 按IP精准查询（排查10.0.0.104设备状态）
    fmt.Println("\n1. IP精准查询结果：")
    searchedDev := sl.Search("10.0.0.104")
    if searchedDev != nil {
        fmt.Printf("IP:%s | CPU:%.1f%% | 内存:%.1f%% | 在线:%t | 更新时间:%d\n",
            searchedDev.IP, searchedDev.CPUUsage, searchedDev.MemoryUsage, searchedDev.IsOnline, searchedDev.UpdateTime)
    } else {
        fmt.Println("未找到该设备")
    }
    // 2. 按CPU范围筛选（查询CPU>80%的异常设备）
    fmt.Println("\n2. CPU异常设备筛选结果（>80%）：")
    abnormalDevs := sl.RangeSearchByCPU(80, 100)
    for _, dev := range abnormalDevs {
        fmt.Printf("IP:%s | CPU:%.1f%% | 内存:%.1f%% | 在线:%t\n",
            dev.IP, dev.CPUUsage, dev.MemoryUsage, dev.IsOnline)
    }
}