Types and rules of channels in concurrent programming of Golang functions

Channel is a communication mechanism in Go language for safely transferring data between concurrent functions. It provides data competition protection to avoid direct access to shared memory. Channel types include unbuffered channel (chan T) and buffered channel (chan T, int). Rules include sending a value (

Channel types and rules in concurrent programming of Go language functions

Channels are used in the Go language to communicate between concurrent functions A communication mechanism to deliver data securely. They provide a layer of abstraction that eliminates the need for functions to access shared memory directly, thus avoiding data races.

Channel type

• Unbuffered channel (chan T): This type of channel has no internal buffer, so the sender and receiver Both parties must be in the ready state at the same time to communicate.
• Buffered channel (chan T, int): This type of channel has an internal buffer of a specified size for storing values. It allows the sender to send a value when the receiver is not ready to receive it, and vice versa.

Channel rules

• Send values: Use the send operator (&lt ;-) Send the value to the channel. The channel must be locked using before sending the value.
• Receive a value: Receive a value from a channel using the receive operator (->). Similar to sending values, the channel must be locked using chan before receiving values.
• Close the channel: Use close(chan) to close the channel. After closing, no more values ​​can be sent to the channel, but already sent values ​​can continue to be received.
• Channel capacity: The buffer channel has a specified maximum capacity, determined by the second parameter specified when creating. If the channel is full, the sender blocks until space becomes available.
• Select: The select statement allows selective receiving or sending from multiple channels. It provides an event-driven concurrent programming model.

Practical Case

Consider a program that calculates prime numbers:

package main

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

// 工作单元
type WorkUnit struct {
    n        uint64
    isPrime  bool
    finished chan bool
}

// 素数计算函数
func isPrime(n uint64) bool {
    if n <= 1 {
        return false
    }
    for i := uint64(2); i <= uint64(math.Sqrt(float64(n))); i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 工作器函数
func worker(in, out chan *WorkUnit, wg *sync.WaitGroup) {
    defer wg.Done()
    for unit := range in {
        unit.isPrime = isPrime(unit.n)
        close(unit.finished)
        out <- unit
    }
}

func main() {
    // 输入通道
    in := make(chan *WorkUnit)
    // 输出通道
    out := make(chan *WorkUnit)

    // 初始化工作单元
    units := make([]*WorkUnit, 500000)
    for i := range units {
        units[i] = &WorkUnit{
            n:        uint64(i),
            finished: make(chan bool),
        }
    }

    // 启动工作器
    wg := &sync.WaitGroup{}
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker(in, out, wg)
    }

    // 将工作单元推送到输入通道
    start := time.Now()
    for _, unit := range units {
        in <- unit
    }
    close(in)

    // 从输出通道接收结果
    for unit := range out {
        <-unit.finished
    }
    elapsed := time.Since(start)

    fmt.Printf("Took %s\n", elapsed)
}

In this example:

• in Channels are unbuffered channels used to send units of work to worker functions.
• out The channel is a buffer channel used to transfer calculation results back to the main function.
• finished The channel is an unbuffered channel used to signal the main function after the worker function has completed its calculation.

This program demonstrates how to use channels to implement concurrent calculations in Go, effectively utilizing multiple CPU cores.

The above is the detailed content of Types and rules of channels in concurrent programming of Golang functions. For more information, please follow other related articles on the PHP Chinese website!