Go语言中接口实例与唯一ID的健壮映射实现

type MyTask struct {
    data map[string]string
    // ...
}

package main

import (
    "fmt"
    "math/rand"
    "sync" // 用于并发安全
    "time" // 用于初始化rand种子
)

// Task 接口现在包含一个 ID() 方法
type Task interface {
    Do() error
    ID() int64
}

// XTask 是 Task 接口的一个具体实现
type XTask struct {
    id int64
    // other stuff, e.g., a map which would make XTask non-comparable
    data map[string]string
}

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

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

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

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

    var id int64
    for {
        // 生成一个随机的 int64 ID
        id = rand.Int63()
        // 检查 ID 是否已存在，确保唯一性
        if _, exists := taskRegistry[id]; !exists {
            break // ID 唯一，跳出循环
        }
    }
    // 将任务实例注册到表中
    taskRegistry[id] = t
    return id
}

// NewXTask 是 XTask 的构造函数，负责初始化并注册任务
func NewXTask( /* task parameters... */ ) *XTask {
    t := &XTask{
        data: make(map[string]string), // 示例：包含一个不可比较的map
    }
    t.id = Register(t) // 在构造时自动注册并获取ID
    // possibly more initialization...
    return t
}

package main

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

// Task 接口现在包含一个 ID() 方法
type Task interface {
    Do() error
    ID() int64
}

// XTask 是 Task 接口的一个具体实现
type XTask struct {
    id   int64
    data map[string]string // 示例：包含一个不可比较的map
    // other stuff
}

// NewXTask 是 XTask 的构造函数，负责初始化并注册任务
func NewXTask( /* task parameters... */ ) *XTask {
    t := &XTask{
        data: make(map[string]string), // 示例：包含一个不可比较的map
    }
    t.id = Register(t) // 在构造时自动注册并获取ID
    // possibly more initialization...
    return t
}

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

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

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

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

    var id int64
    for {
        // 生成一个随机的 int64 ID
        id = rand.Int63()
        // 检查 ID 是否已存在，确保唯一性
        if _, exists := taskRegistry[id]; !exists {
            break // ID 唯一，跳出循环
        }
    }
    // 将任务实例注册到表中
    taskRegistry[id] = t
    return id
}

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

    t1 := NewXTask()
    t2 := NewXTask()
    t3 := NewXTask()

    fmt.Printf("Task 1 ID: %x\n", t1.ID())
    fmt.Printf("Task 2 ID: %x\n", t2.ID())
    fmt.Printf("Task 3 ID: %x\n", t3.ID())

    t1.Do()
    t2.Do()
    t3.Do()

    // 示例：通过 ID 从注册表中查找任务
    if task, ok := taskRegistry[t1.ID()]; ok {
        fmt.Printf("Found task with ID %x in registry.\n", task.ID())
    }
}

Task 1 ID: 4945781a96752382
Task 2 ID: 31c944111352a1d2
Task 3 ID: 62208153406b2c2b
Task 4945781a96752382 is doing something.
Task 31c944111352a1d2 is doing something.
Task 62208153406b2c2b is doing something.
Found task with ID 4945781a96752382 in registry.

type LibraryTask struct {
    id   int64
    task Task // 原始的 Task 接口实例
}

func NewLibraryTask(t Task) *LibraryTask {
    lt := &LibraryTask{task: t}
    lt.id = Register(lt) // 注意：这里需要修改 Register 接收 *LibraryTask 或其他方式
    return lt
}

func (lt *LibraryTask) Do() error {
    return lt.task.Do()
}

func (lt *LibraryTask) ID() int64 {
    return lt.id
}