golang协程矩阵运算 [推广有奖]

0关注
0粉丝

等待验证会员

小学生

71%

还不是VIP/贵宾

-

0%

威望: 0 级
论坛币: 0 个
通用积分: 0
学术水平: 0 点
热心指数: 0 点
信用等级: 0 点
经验: 60 点
帖子: 5
精华: 0
在线时间: 0 小时
注册时间: 2018-9-11
最后登录: 2018-9-11

楼主

AHUAHUAHU 发表于 2025-12-11 13:23:38 |AI写论文

是否 +2 论坛币

k人参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

// 矩阵乘法函数 - 基于ants协程池实现并行计算
func parallelMatrixMultiply(A, B [][]int) [][]int {
    rowsA := len(A)
    colsA := len(A[0])
    rowsB := len(B)
    colsB := len(B[0])

    // 验证矩阵维度是否满足相乘条件
    if colsA != rowsB {
        return nil
    }

    // 初始化结果矩阵
    result := make([][]int, rowsA)
    for i := range result {
        result[i] = make([]int, colsB)
    }

    // 创建协程池，大小设置为当前机器的CPU核心数
    pool, err := ants.NewPool(runtime.NumCPU())
    if err != nil {
        panic(err)
    }
    defer pool.Release()

    var wg sync.WaitGroup

    // 为矩阵A的每一行分配一个并发任务
    for i := 0; i < rowsA; i++ {
        wg.Add(1)
        row := i // 防止闭包中变量捕获问题
        err = pool.Submit(func() {
            defer wg.Done()
            // 计算该行在结果矩阵中的每个元素值
            for j := 0; j < colsB; j++ {
                sum := 0
                for k := 0; k < colsA; k++ {
                    sum += A[row][k] * B[k][j]
                }
                result[row][j] = sum
            }
        })
        if err != nil {
            panic(err)
        }
    }

    // 等待所有并行任务完成
    wg.Wait()
    return result
}

// 顺序执行的矩阵乘法函数（不使用并发）
func sequentialMatrixMultiply(A, B [][]int) [][]int {
    rowsA := len(A)
    colsA := len(A[0])
    rowsB := len(B)
    colsB := len(B[0])

    // 判断矩阵是否可以相乘
    if colsA != rowsB {
        return nil
    }

    // 构建结果矩阵结构
    result := make([][]int, rowsA)
    for i := range result {
        result[i] = make([]int, colsB)
    }

    // 使用三重循环进行标准矩阵乘法运算
    for i := 0; i < rowsA; i++ {
        for j := 0; j < colsB; j++ {
            sum := 0
            for k := 0; k < colsA; k++ {
                sum += A[i][k] * B[k][j]
            }
            result[i][j] = sum
        }
    }
    return result
}

// 生成指定大小的测试用矩阵
func generateMatrix(size int) [][]int {
    matrix := make([][]int, size)
    for i := range matrix {
        matrix[i] = make([]int, size)
        for j := range matrix[i] {
            matrix[i][j] = i + j
        }
    }
    return matrix
}

// 主函数：执行性能对比测试
func main() {
    const matrixSize = 1000
    A := generateMatrix(matrixSize)
    B := generateMatrix(matrixSize)

    // 测量并行版本运行时间
    parallelStart := time.Now()
    parallelResult := parallelMatrixMultiply(A, B)
    parallelDuration := time.Since(parallelStart)

    // 测量顺序版本运行时间
    sequentialStart := time.Now()
    sequentialResult := sequentialMatrixMultiply(A, B)
    sequentialDuration := time.Since(sequentialStart)

    // 输出两种方式的耗时（单位：纳秒）
    fmt.Println("并行版本执行时间: ", parallelDuration.Nanoseconds())
    fmt.Println("顺序版本执行时间: ", sequentialDuration.Nanoseconds())
}

// 验证计算结果的一致性
if len(parallelResult) > 0 && len(sequentialResult) > 0 {
    consistent := true
    for i := range parallelResult {
        for j := range parallelResult[i] {
            if parallelResult[i][j] != sequentialResult[i][j] {
                consistent = false
                break
            }
        }
        if !consistent {
            break
        }
    }
    if consistent {
        fmt.Println("结果一致")
    } else {
        fmt.Println("结果不一致")
    }
}

 

// 输出性能对比数据
fmt.Printf("性能提升: %d 倍\n", sequentialDuration.Nanoseconds()/parallelDuration.Nanoseconds())

当矩阵规模为千行千列时，并行计算与顺序执行之间仍存在一定差距。为了获得更明显的性能优势，建议将矩阵的维度设置不低于74。这是因为，在较小规模下，创建协程以及调度所带来的额外开销可能会超过并行化所带来的时间节省，从而导致整体效率反而下降。

执行结果示例：