Go接口实例到ID的映射：解决非可比较类型挑战

type MyTask struct {
    data map[string]string // map类型不可比较
    // ... 其他字段
}

func (t *MyTask) Do() error { /* ... */ return nil }

type Task interface {
    Do() error
    ID() int64 // 新增：返回任务的唯一ID
}

import (
    "math/rand"
    "time"
)

var taskRegistry = map[int64]Task{}

func init() {
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子
}

// Register 为给定的Task实例生成一个唯一ID，并将其注册到全局注册表中
func Register(t Task) int64 {
    var id int64
    for {
        id = rand.Int63() // 生成一个随机的int64作为ID
        if id == 0 { // 避免ID为0，0有时有特殊含义
            continue
        }
        if _, exists := taskRegistry[id]; !exists {
            break // 找到一个未使用的ID
        }
    }
    taskRegistry[id] = t // 将ID与Task实例关联
    return id
}

// XTask 是Task接口的一个具体实现
type XTask struct {
    id int64 // 存储任务的唯一ID
    name string
    // ... 其他业务相关字段，可以包含不可比较类型，例如 map
    internalData map[string]interface{}
}

// NewXTask 是XTask的构造函数，负责初始化并注册任务
func NewXTask(name string /* 其他任务参数... */) *XTask {
    t := &XTask{
        name: name,
        internalData: make(map[string]interface{}), // 示例：包含一个不可比较的map
    }
    t.id = Register(t) // 在创建时注册任务并获取ID
    // 更多初始化...
    return t
}

// Do 实现Task接口的Do方法
func (t *XTask) Do() error {
    fmt.Printf("Task %s (ID: %x) is doing its work.\n", t.name, t.id)
    return nil
}

// ID 实现Task接口的ID方法，返回任务的唯一ID
func (t *XTask) ID() int64 {
    return t.id
}

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

// Task 接口定义
type Task interface {
    Do() error
    ID() int64 // 新增：返回任务的唯一ID
}

// XTask 是Task接口的一个具体实现
type XTask struct {
    id   int64 // 存储任务的唯一ID
    name string
    // ... 其他业务相关字段，可以包含不可比较类型，例如 map
    internalData map[string]interface{}
}

// NewXTask 是XTask的构造函数，负责初始化并注册任务
func NewXTask(name string /* 其他任务参数... */) *XTask {
    t := &XTask{
        name: name,
        internalData: make(map[string]interface{}), // 示例：包含一个不可比较的map
    }
    t.id = Register(t) // 在创建时注册任务并获取ID
    // 更多初始化...
    return t
}

// Do 实现Task接口的Do方法
func (t *XTask) Do() error {
    fmt.Printf("Task %s (ID: %x) is doing its work.\n", t.name, t.id)
    return nil
}

// ID 实现Task接口的ID方法，返回任务的唯一ID
func (t *XTask) ID() int64 {
    return t.id
}

// taskRegistry 用于存储ID到Task实例的映射
var taskRegistry = map[int64]Task{}
// registryMutex 用于保护taskRegistry的并发访问
var registryMutex sync.Mutex

func init() {
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子
}

// Register 为给定的Task实例生成一个唯一ID，并将其注册到全局注册表中
func Register(t Task) int64 {
    registryMutex.Lock() // 加锁以保证并发安全
    defer registryMutex.Unlock()

    var id int64
    for {
        id = rand.Int63() // 生成一个随机的int64作为ID
        if id == 0 { // 避免ID为0，0有时有特殊含义
            continue
        }
        if _, exists := taskRegistry[id]; !exists {
            break // 找到一个未使用的ID
        }
    }
    taskRegistry[id] = t // 将ID与Task实例关联
    return id
}

func main() {
    fmt.Println("开始创建和注册任务...")

    t1 := NewXTask("Task A")
    t2 := NewXTask("Task B")
    t3 := NewXTask("Task C")

    fmt.Printf("任务 '%s' 的ID: %x\n", t1.name, t1.ID())
    fmt.Printf("任务 '%s' 的ID: %x\n", t2.name, t2.ID())
    fmt.Printf("任务 '%s' 的ID: %x\n", t3.name, t3.ID())

    // 模拟任务执行
    t1.Do()
    t2.Do()

    // 演示通过ID从注册表中检索Task实例
    fmt.Println("\n通过ID检索任务...")
    if retrievedTask, ok := taskRegistry[t2.ID()]; ok {
        fmt.Printf("检索到ID为 %x 的任务 '%s'.\n", t2.ID(), retrievedTask.(*XTask).name)
        retrievedTask.Do()
    } else {
        fmt.Printf("未找到ID为 %x 的任务.\n", t2.ID())
    }

    fmt.Println("\n所有注册的任务:")
    for id, task := range taskRegistry {
        fmt.Printf("ID: %x, Name: %s\n", id, task.(*XTask).name)
    }
}