DEV Community


Posted on

Learning Golang 107


Concurrent programming in many environments is made difficult by the subtleties required to implement correct access to shared variables. Go encourages a different approach in which shared values are passed around on channels and, in fact, never actively shared by separate threads of execution. Only one goroutine has access to the value at any given time. Data races cannot occur, by design. I think this really makes go so shining.


Prefix a function or method call with the go keyword to run the call in a new goroutine. When the call completes, the goroutine exits, silently.

func Announce(message string, delay time.Duration) {
    go func() {
    }()  // Note the parentheses - must call the function.
Enter fullscreen mode Exit fullscreen mode

A channel can allow the launching goroutine to wait for the sort to complete.

c := make(chan int)  // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
    c <- 1  // Send a signal; value does not matter.
<-c   // Wait for sort to finish; discard sent value.
Enter fullscreen mode Exit fullscreen mode

Receivers always block until there is data to receive. If the channel is unbuffered, the sender blocks until the receiver has received the value. If the channel has a buffer, the sender blocks only until the value has been copied to the buffer; if the buffer is full, this means waiting until some receiver has retrieved a value.

A buffered channel can be used like a semaphore, for instance to limit throughput. In this example, incoming requests are passed to handle, which sends a value into the channel, processes the request, and then receives a value from the channel to ready the β€œsemaphore” for the next consumer. The capacity of the channel buffer limits the number of simultaneous calls to process.

var sem = make(chan int, MaxOutstanding)

func handle(r *Request) {
    sem <- 1    // Wait for active queue to drain.
    process(r)  // May take a long time.
    <-sem       // Done; enable next request to run.

func Serve(queue chan *Request) {
    for {
        req := <-queue
        go handle(req)  // Don't wait for handle to finish.
Enter fullscreen mode Exit fullscreen mode

Channels of channels

One of the most important properties of Go is that a channel is a first-class value that can be allocated and passed around like any other.

type Request struct {
    args        []int
    f           func([]int) int
    resultChan  chan int

func sum(a []int) (s int) {
    for _, v := range a {
        s += v

request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)

Enter fullscreen mode Exit fullscreen mode

Function Literals

As lambda in java, Go supports Function Literals. It is a function without a name.

c := make(chan int)
func(ch chan int) {
    ch <- 1  // Send a signal; value does not matter.
}(c)  // the () means call the function.
Enter fullscreen mode Exit fullscreen mode

Top comments (0)