如何充分利用所有处理器核心进行for循环操作？

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《如何充分利用所有处理器核心进行for循环操作？》，涉及到，有需要的可以收藏一下

我有一个标准的 for 循环。我有一个 8 核处理器，16 线程。当我运行这个循环时，我发现只有 1 个线程利用率为 100%。 我希望示例中的一个循环由所有 cpu 核心处理，这可能吗？ 我看到了 goroutine，但根据上下文，通常存在并行独立任务。有人可以修复我的代码，使其使用所有 cpu 核心吗？

package main

import (
    "fmt"
    "net/http"
    "runtime"
    "time"
)

func main() {
    fmt.Println(runtime.NumCPU())
    fmt.Println("hi man!");
    timestart := time.Now();

    for i := int64(0); i < 9007199915; i++ {
        if (testMy(i) == true) {
            fmt.Println("was returned true")
        }
    }

    timeend := time.Now();

    fmt.Print(timeend.Sub(timestart));
}



func testMy(someInteger int64) (bool) {
    if (someInteger == 5) {
        return true;
    } else if (someInteger == 900199) {
        return true;
    } else if (someInteger == 9001999) {
        return true;
    } else {
        return false;
    }
}

更新：任何人都可以建议一种编程语言在这种情况下可以实现吗？也就是说，采用我的 for 循环循环并在低级别上对其进行并行化。

解决方案

在go中很简单，只需使用 goroutine 在 cpu 核心之间划分任务即可。
让我给你举个例子（参见这个 for k := 0; k < ncpu; k++ {...} 循环）：
想象一下，您需要知道使用所有 cpu 核心的最大 64 位素数（与您的问题类似，这里是一个 for 循环，我在 cpu 核心之间划分了它： for i := start; i <= end &&atomic.loadint32(&quit ) == 0; i += 2 {...}):

package main

import (
    "fmt"
    "math"
    "runtime"
    "sync"
    "sync/atomic"
)

func main() {
    // find max uint64 prime
    n := uint64(math.maxuint64)
    for ; !isoddprime(n); n -= 2 {
    }
    fmt.println(n) // 18446744073709551557
}

var ncpu = runtime.numcpu()

func isoddprime(n uint64) bool {
    q := uint64(math.sqrt(float64(n)))
    step := q / uint64(ncpu)
    if step&1 == 1 {
        step++ // make it even
    }
    var wg sync.waitgroup
    wg.add(ncpu)
    var quit int32
    start := uint64(3)
    for k := 0; k < ncpu; k++ {
        end := start + step
        if end > q {
            end = q
        }
        go func(start, end uint64) {
            defer wg.done()
            for i := start; i <= end && atomic.loadint32(&quit) == 0; i += 2 {
                if n%i == 0 {
                    atomic.storeint32(&quit, 1)
                    return
                }
            }
        }(start, end)
        start = end + 2
    }
    wg.wait()
    return quit == 0
}

8核输出：

18446744073709551557
real    0m5.551s
user    0m39.059s
sys     0m0.040s

1核输出：

18446744073709551557
real    0m23.704s
user    0m23.611s
sys     0m0.024s

原始代码（没有同步和调度开销）：

package main

import (
    "fmt"
    "math"
)

func isoddprime(n uint64) bool {
    q := uint64(math.sqrt(float64(n)))
    for i := uint64(3); i <= q; i += 2 {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() { // find max uint64 prime
    n := uint64(math.maxuint64)
    for ; !isoddprime(n); n -= 2 {
    }
    fmt.println(n) // 18446744073709551557
}

使用 go build -o $tmpdir/main && time $tmpdir/main 的 go 版本 go1.13.4 linux/amd64 的输出：

18446744073709551557

real    0m24.002s
user    0m24.002s
sys     0m0.012s

理论要掌握，实操不能落！以上关于《如何充分利用所有处理器核心进行for循环操作？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！