从Golang工作线程返回任务结果的实现方法

要实现从工作线程返回任务结果，可以使用带缓冲的结果通道。以下是修改后的代码示例：

package main

import (
	"fmt"
	"time"
)

func main() {
	w := NewWorker()
	w.Start()

	// 启动结果监听协程
	go func() {
		for result := range w.ResultChan() {
			fmt.Printf("收到结果: %s\n", result)
		}
	}()

	for i := 0; i < 19; i++ {
		j := NewJob(i)
		w.Add(j)
		
		time.Sleep(time.Second)
	}

	// 等待所有任务完成
	time.Sleep(5 * time.Second)
}

// ----------------------------------------------------------------------------------------

type Job struct {
	id int
}

func NewJob(id int) *Job {
	return &Job{
		id: id,
	}
}

// ----------------------------------------------------------------------------------------

type Worker struct {
	total      int
	jobChannel chan *Job
	resultChan chan string
}

func NewWorker() *Worker {
	return &Worker{
		total:      3,
		jobChannel: make(chan *Job, 100),
		resultChan: make(chan string, 100),
	}
}

func (w *Worker) Start() {
	for i := 1; i <= w.total; i++ {
		go w.run(i)
	}
}

func (w *Worker) Add(job *Job) {
	w.jobChannel <- job
}

func (w *Worker) ResultChan() <-chan string {
	return w.resultChan
}

func (w *Worker) run(id int) {
	fmt.Printf("worker %d started...\n", id)

	for {
		select {
		case job := <-w.jobChannel:
			fmt.Printf("%d processing job %d\n", id, job.id)

			// 处理任务并生成结果
			result := fmt.Sprintf("任务 %d 由 worker %d 完成 @ %s", 
				job.id, id, time.Now().UTC().Format("15:04:05"))
			
			// 将结果发送到结果通道
			w.resultChan <- result
			
		default:
			time.Sleep(1 * time.Second)
			fmt.Println("sleeping")
		}
	}
}

另一种更简洁的实现方式是使用带返回值的任务函数：

package main

import (
	"fmt"
	"time"
)

func main() {
	w := NewWorker()
	w.Start()

	// 提交任务并获取结果通道
	for i := 0; i < 10; i++ {
		taskID := i
		resultChan := w.Submit(func() string {
			time.Sleep(500 * time.Millisecond)
			return fmt.Sprintf("任务 %d 完成 @ %s", 
				taskID, time.Now().Format("15:04:05.000"))
		})

		// 异步获取结果
		go func(id int, ch <-chan string) {
			result := <-ch
			fmt.Printf("任务 %d 结果: %s\n", id, result)
		}(taskID, resultChan)
	}

	time.Sleep(3 * time.Second)
}

type Worker struct {
	taskChan chan func() string
}

func NewWorker() *Worker {
	return &Worker{
		taskChan: make(chan func() string, 100),
	}
}

func (w *Worker) Start() {
	for i := 0; i < 3; i++ {
		go func(workerID int) {
			for task := range w.taskChan {
				result := task()
				fmt.Printf("Worker %d 处理完成\n", workerID)
				// 在实际实现中，这里需要将结果传回
			}
		}(i)
	}
}

func (w *Worker) Submit(task func() string) <-chan string {
	resultChan := make(chan string, 1)
	
	wrappedTask := func() string {
		result := task()
		resultChan <- result
		return result
	}
	
	w.taskChan <- wrappedTask
	return resultChan
}

使用 sync.WaitGroup 等待所有任务完成的完整示例：

package main

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

func main() {
	w := NewWorker(3)
	w.Start()

	var wg sync.WaitGroup
	results := make(chan string, 10)

	// 提交任务
	for i := 0; i < 10; i++ {
		wg.Add(1)
		taskID := i
		
		go func() {
			defer wg.Done()
			
			result := w.Process(taskID)
			results <- result
		}()
	}

	// 等待所有任务完成并关闭结果通道
	go func() {
		wg.Wait()
		close(results)
	}()

	// 收集结果
	for result := range results {
		fmt.Println("收到结果:", result)
	}
}

type Worker struct {
	workers int
	tasks   chan int
	results chan string
	wg      sync.WaitGroup
}

func NewWorker(workers int) *Worker {
	return &Worker{
		workers: workers,
		tasks:   make(chan int, 100),
		results: make(chan string, 100),
	}
}

func (w *Worker) Start() {
	for i := 0; i < w.workers; i++ {
		w.wg.Add(1)
		go func(workerID int) {
			defer w.wg.Done()
			for taskID := range w.tasks {
				// 模拟处理时间
				time.Sleep(100 * time.Millisecond)
				
				result := fmt.Sprintf("任务 %d 由 worker %d 完成", 
					taskID, workerID)
				w.results <- result
			}
		}(i)
	}
}

func (w *Worker) Process(taskID int) string {
	w.tasks <- taskID
	return <-w.results
}

func (w *Worker) Stop() {
	close(w.tasks)
	w.wg.Wait()
	close(w.results)
}

这些示例展示了如何在Golang中从工作线程返回任务结果，包括使用结果通道、异步回调等模式。关键点是为每个任务创建结果通道，或者使用共享的结果通道配合任务ID来关联结果。