Golang中如何为每个循环创建一个线程

Golang中如何为每个循环创建一个线程 大家好，我正在尝试实现两个for循环，每个循环在单独的线程中运行。我的背景是C++（图像处理）。在C++中，我可以为每个for循环启动一个线程，这样，在同一个主函数中，每个循环可以并发执行。以下是简化后的代码：

import (
	"fmt"
	"os"
	"sync"

	"github.com/antonel/owe-sdk-go/v1"
	"github.com/joho/godotenv"
)

func main() {

	//我希望在这里启动线程1
	for i := 0; i < 1000; i++ {

		Work(node 1/port8080)
	
	}

    //在这里启动第二个线程
    for i := 0; i < 1000; i++ {

		Work(node 2/port7070)
		
	}


}

我找到了关于WaitGroup/go func的示例，但看起来它们只在循环内部工作，而不是针对不同的for循环，至少我是这样理解的。请给我一些帮助。


更多关于Golang中如何为每个循环创建一个线程的实战教程也可以访问 https://www.itying.com/category-94-b0.html

6 回复

感谢你用手机写下这些！😊

更多关于Golang中如何为每个循环创建一个线程的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


谢谢！我本想提一下的，但在我花了那么多天在手机上写那段代码之后，它似乎被遗漏了。

是的，我读过这篇文章（谢谢），看起来 goroutine 并不一定是另一个线程，但在某些情况下它可以调用一个新线程。

你需要将每个循环包装成一个 go 协程，然后使用一个 WaitGroup 来最终重新汇合你的三个协程。

大致伪代码如下，因为我在手机上：

func main() {
    wg = new(WaitGroup)
    wg.Add(2)
    
    go func(innerWG WaitGroup) {
        for ... { ... }
        innerWG.Done()
    }(wg)

    go func(innerWG WaitGroup) {
        for ... { ... }
        innerWG.Done()
    }(wg)

    wg.Wait()
}

需要快速说明的是，goroutine 不一定是线程：

Medium

为什么 goroutine 不是轻量级线程？

文章缩略图

如今 GoLang 正获得令人难以置信的流行度。其中一个主要原因是其简单轻量的并发形式…

阅读时间：5 分钟

我相当确定您指的是 “goroutine” 而不是 “thread”，但觉得值得指出这一点。

在Go中，你可以使用goroutine为每个循环创建并发执行单元。以下是实现方式：

package main

import (
    "fmt"
    "sync"
)

func work(node string, port int, i int) {
    fmt.Printf("Node: %s, Port: %d, Iteration: %d\n", node, port, i)
    // 你的实际工作逻辑
}

func main() {
    var wg sync.WaitGroup
    
    // 启动第一个循环的goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            work("node 1", 8080, i)
        }
    }()
    
    // 启动第二个循环的goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            work("node 2", 7070, i)
        }
    }()
    
    // 等待两个goroutine完成
    wg.Wait()
    fmt.Println("All loops completed")
}

如果你希望更简洁的写法，可以使用函数封装：

package main

import (
    "fmt"
    "sync"
)

func work(node string, port int, i int) {
    fmt.Printf("Node: %s, Port: %d, Iteration: %d\n", node, port, i)
}

func runLoop(node string, port int, iterations int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < iterations; i++ {
        work(node, port, i)
    }
}

func main() {
    var wg sync.WaitGroup
    
    wg.Add(2)
    go runLoop("node 1", 8080, 1000, &wg)
    go runLoop("node 2", 7070, 1000, &wg)
    
    wg.Wait()
    fmt.Println("All loops completed")
}

如果你需要控制并发数量或处理错误，可以使用带缓冲的channel：

package main

import (
    "fmt"
    "sync"
)

func work(node string, port int, i int) error {
    fmt.Printf("Node: %s, Port: %d, Iteration: %d\n", node, port, i)
    return nil
}

func main() {
    var wg sync.WaitGroup
    errCh := make(chan error, 2)
    
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            if err := work("node 1", 8080, i); err != nil {
                errCh <- err
                return
            }
        }
    }()
    
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            if err := work("node 2", 7070, i); err != nil {
                errCh <- err
                return
            }
        }
    }()
    
    // 等待goroutines完成
    go func() {
        wg.Wait()
        close(errCh)
    }()
    
    // 检查错误
    for err := range errCh {
        fmt.Printf("Error occurred: %v\n", err)
    }
    
    fmt.Println("All loops completed")
}

这些示例展示了如何在Go中为不同的循环创建并发执行，类似于C++中的线程概念。WaitGroup确保主函数等待所有goroutine完成，而goroutine提供了轻量级的并发执行单元。

回到顶部