Go Bible Excerpt

Source: Internet
Author: User

Chapter 8 Goroutines and Channels

Go enable both styles of concurrent programming. This chapter presents coroutines and channels, which support communicating sequential processes or CSP, a model of Concurr Ency in which values is passed between independent activities (Goroutines) but variables is for the most part Confin Ed to a single activity. Chapter 9 covers some aspects of the more traditional model of shared memory multithreading, which would be familiar if you ' ve used threads in the other mainstream languages. Chapter 9 also points out some important hazards and pitfalls of concurrent programming that we won ' t delve to in this C Hapter.
Goroutine two modes, one for two goroutine between the communication, variables is limited to a separate activities.
Another multi-threading, similar to other mainstream languages, is characterized by the shared memory multithreading.

8.1 Goroutines

In Go, each concurrently executing activity is called a goroutine.
In Golang, each concurrently executing activity is called a goroutine.

If you had used operating system threads or threads in other languages, then you can assume for now that a goroutine is s Imilar to a thread, and you'll be able to write correct programs. The differences between threads and Goroutines is essentially quantitative, not qualitative, and would be described in SEC tion 9.8.
The difference between threads and goroutines is quantitative, not qualitative. A further explanation will be made in 9.8.

When a program starts, it's only goroutine are the one that calls the main function, so we call it the main goroutine. New Goroutines is created by the GO statement. Syntactically, a go statement is an ordinary function or method call prefixed by the keyword go. A Go statement causes the function to being called in a newly created goroutine. The GO statement itself completes immediately:
When a program starts, the program's only main function is the main goroutine.

    • F ()
    • Go f ()
package mainimport (    "time"    "fmt")func main() {    go spinner(5 * time.Millisecond)    const n = 45    fibN := fib(n)    fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN)}func spinner(delay time.Duration) {    for {        for _, r := range `-\|/` {            fmt.Printf("\r%c", r)            time.Sleep(delay)        }    }}func fib(x int) int {    if x < 2 {        return x    }    return fib(x - 1) + fib(x - 2)}

The/R in the program indicates carriage return

Other than by returning from main or exiting-the program, there is no programmatic-for-one goroutine to stop another, But as we'll see later, there is ways to communicate with a goroutine to request that it stop itself.
In addition to returning from the main function or exiting the current program, there is no procedural way to let one goroutine stop the other goroutine, but there is a way for a goroutine to send a message to another goroutine to stop himself.

8.2 example:concurrent Clock Server

A clock example
Server

package mainimport (    "net"    "log"    "io"    "time")func main() {    listener, err := net.Listen("tcp", "localhost:8000")    if err != nil {        log.Fatal(err)    }    for {        conn, err := listener.Accept()        if err != nil {            log.Print(err)            continue        }        handleConn(conn)    }}func handleConn(c net.Conn) {    defer c.Close()    for {        _, err := io.WriteString(c, time.Now().Format("15:04:05\n"))        if err != nil {            return        }        time.Sleep(1 * time.Second)    }}

The important thing is three steps:

    • Listener, err: = Net. Listen ("TCP", "localhost:8000")
    • Conn, err: = Listener. Accept ()
    • _, Err: = Io. WriteString (c, time. Now (). Format ("15:04:05\n"))
      Note: The time taken must be 2016/1/2 15:04:05 (123456) January 2 3:4 Five Seconds
      https://segmentfault.com/q/1010000010976398/a-1020000010982052
      Connect using NC commands on the client
      NC localhost 8000
      Client
  Package Mainimport ("NET" "Log" "IO" "OS") Func main () {conn, err: = Net. Dial ("TCP", "localhost:8000") if err! = Nil {log. Fatal (ERR)} defer conn. Close () _, Err1: = Io. Copy (OS. STDOUT, conn) if err! = Nil {log. Fatal (ERR1)}}  
Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.