{"id":294,"date":"2024-09-18T15:53:50","date_gmt":"2024-09-18T08:53:50","guid":{"rendered":"https:\/\/gotutorial.org\/?page_id=294"},"modified":"2024-09-23T15:42:35","modified_gmt":"2024-09-23T08:42:35","slug":"goroutines","status":"publish","type":"page","link":"https:\/\/www.gotutorial.org\/go-tutorial\/goroutines\/","title":{"rendered":"Goroutines"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how to use goroutines to develop concurrent applications.<\/p>\n\n\n\n

Processes and Threads<\/h2>\n\n\n\n

When you launch a Go Program, the operating system (OS) creates a new process<\/em>. A process is a container that holds program resources, including memory and threads<\/em>:<\/p>\n\n\n\n

\"Simplified<\/figure>\n\n\n\n

Each process contains at least one thread known as the main thread<\/em>. The main thread is the entry point for the application. When the main thread terminates, the application exits.<\/p>\n\n\n\n

When a program has a single thread, it is called a single-threaded program. A process may contain multiple threads. In this case, the program is known as a multi-threaded program<\/em>.<\/p>\n\n\n\n

To execute multiple threads, the OS uses a scheduler to schedule the threads to run:<\/p>\n\n\n\n

\"Threads\"<\/figure>\n\n\n\n

If the computer has a single CPU, the scheduler switches between threads so fast that often gives us an illusion <\/em>that they are running simultaneously<\/em>. This is called concurrency<\/em>.<\/p>\n\n\n\n

Concurrency<\/h2>\n\n\n\n

Concurrency is about to deal with multiple tasks at the same time<\/em>. It doesn’t necessarily mean the tasks are running at the same time:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

On the other hand, parallelism<\/em> is about executing multiple tasks at the same time. This requires multiple processors or cores.<\/p>\n\n\n\n

\"Parallelism\"<\/figure>\n\n\n\n

Nowadays, computers have more than one core. Therefore, the OS scheduler can run multiple threads at the same time, which creates a true parallelism:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

To achieve concurrency, other programming languages such as C# or Java use multi-threading. However, developing multi-threaded programs is hard because we need to synchronize between threads carefully or they will break. <\/p>\n\n\n\n

To make concurrency easy, Go provides a built-in language feature called goroutines<\/em>.<\/p>\n\n\n\n

Goroutines<\/h2>\n\n\n\n

Goroutines are much lighter than OS threads. They are known as lightweight threads and are managed by the Go runtime scheduler<\/em>.<\/p>\n\n\n\n

A lightweight thread does not like an operating system (OS) thread. It uses less memory than the OS thread. One OS thread may include multiple lightweight threads.<\/p>\n\n\n\n

The Go runtime scheduler is sitting on top of the OS layer and is in charge of managing the execution of goroutines:<\/p>\n\n\n\n

\"goroutines\"<\/figure>\n\n\n\n

The Go runtime scheduler allows goroutines to run concurrently on a single logical processor or in parallel on multiple logical processors. This enables efficient use of system resources and improves performance.<\/p>\n\n\n\n

The Go runtime scheduler is designed to handle tens or even hundreds of thousands of goroutines efficiently, making Go well-suited for highly concurrent applications.<\/p>\n\n\n\n

Sequential programs<\/h2>\n\n\n\n

Typically, a Go program executes code in sequence line by line from top to bottom. For example:<\/p>\n\n\n

package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"time\"<\/span>\n)\n\nfunc<\/span> task<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(name, \"started...\"<\/span>)\n    time.Sleep(1<\/span> * time.Second)\n    fmt.Println(name, \"finished\"<\/span>)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    \/\/ measure the execution time<\/span>\n    start := time.Now()\n    defer<\/span> func<\/span>()<\/span><\/span> {\n        elapsed := time.Since(start)\n        fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n    }()\n\n    task(\"Task 1\"<\/span>)\n    task(\"Task 2\"<\/span>)\n    task(\"Task 3\"<\/span>)\n\n    fmt.Println(\"Done\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define a function task()<\/code> that takes 1 second to finish:<\/p>\n\n\n
func<\/span> task<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(name, \"started...\"<\/span>)\n    time.Sleep(1<\/span> * time.Second)\n    fmt.Println(name, \"finished\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
The task()<\/code> function uses the Sleep()<\/code> function from the time<\/code> module to pause the execution for one second. <\/p>\n\n\n\n
In real-world applications, the task()<\/code> function may call an external API or make a database connection instead of using the Sleep()<\/code> function.<\/p>\n\n\n\n
Second, measure the execution time of the main()<\/code> function:<\/p>\n\n\n
start := time.Now()\ndefer<\/span> func<\/span>()<\/span><\/span> {\n    elapsed := time.Since(start)\n    fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n}()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, call the task()<\/code> function three times with different string arguments:<\/p>\n\n\n
task(\"Task 1\"<\/span>)\ntask(\"Task 2\"<\/span>)\ntask(\"Task 3\"<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, display the Done<\/code> message:<\/p>\n\n\n
fmt.Println(\"Done\"<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Task 1<\/span> started...\nTask 1<\/span> finished\nTask 2<\/span> started...\nTask 2<\/span> finished\nTask 3<\/span> started...\nTask 3<\/span> finished\nDone\nIt took 3002<\/span> ms<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
The output shows two important pieces of information:<\/p>\n\n\n\n
    \n
  • The tasks started and finished in sequence.<\/li>\n\n\n\n
  • Each task function call took one second to finish. Since we called the task()<\/code> function three times, the whole program took about 3 seconds to complete.<\/li>\n<\/ul>\n\n\n\n
    To speed up the program, we can use goroutines to run the task<\/code> function concurrently.<\/p>\n\n\n\n
    Creating Goroutines<\/h2>\n\n\n\n
    To start a goroutine, you use the go<\/code> keyword followed by a function call that you want to run in a concurrently:<\/p>\n\n\n
    go<\/span> fn()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The go<\/code> keyword instructs the Go runtime scheduler to spawn a new lightweight thread and run the fn()<\/code> function.<\/p>\n\n\n\n
    For example, we can use goroutines to run the task<\/code> function concurrently as follows:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"time\"<\/span>\n)\n\nfunc<\/span> task<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(name, \"started...\"<\/span>)\n    time.Sleep(1<\/span> * time.Second)\n    fmt.Println(name, \"finished\"<\/span>)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    \/\/ measure the execution time<\/span>\n    start := time.Now()\n    defer<\/span> func<\/span>()<\/span><\/span> {\n        elapsed := time.Since(start)\n        fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n    }()\n\n    go<\/span> task(\"Task 1\"<\/span>)\n    go<\/span> task(\"Task 2\"<\/span>)\n    go<\/span> task(\"Task 3\"<\/span>)\n\n    fmt.Println(\"Done\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Done\nIt took 0<\/span> ms<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    It seems that the task()<\/code> function was not executed at all. The reason is that the main()<\/code> function ran so fast, that the task()<\/code> function did not get a chance to execute:<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    To allow the task()<\/code> function to run, the main()<\/code> function must wait for the goroutines to run to complete. <\/p>\n\n\n\n
    Go provides synchronization primitives to do it:<\/p>\n\n\n\n
      \n
    • Using WaitGroup<\/code> objects from the sync module.<\/li>\n\n\n\n
    • Using Channels<\/em>.<\/li>\n<\/ul>\n\n\n\n
      We’ll focus on the WaitGroup<\/code> in this tutorial.<\/p>\n\n\n\n
      Go WaitGroup<\/h2>\n\n\n\n
      In Go, WaitGroup<\/code> is used to wait for a group of goroutines to complete execution. <\/p>\n\n\n\n
      A WaitGroup<\/code> works like a counter: <\/p>\n\n\n\n
        \n
      • First, set the initial counter value which represents the number of goroutines to wait for.<\/li>\n\n\n\n
      • Second, decrease the counter value each time a goroutine is completed.<\/li>\n\n\n\n
      • Third, wait until the counter becomes zero.<\/li>\n<\/ul>\n\n\n\n
        Using a WaitGroup<\/h3>\n\n\n\n
        Here are the steps for using WaitGroup<\/code>:<\/p>\n\n\n\n
        First, declare a variable with the sync.WaitGroup<\/code> type:<\/p>\n\n\n
        var<\/span> wg sync.WaitGroup<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Second, set the counter for the WaitGroup<\/code> to n<\/code>, which represents the number of goroutines to wait for:<\/p>\n\n\n
        wg.Add(n)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Third, call the Done()<\/code> function in the goroutine to decrement the counter once the goroutine completes:<\/p>\n\n\n
        defer<\/span> wg.Done()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Finally, call the wg.Wait<\/code>() function to wait until all goroutine completes:<\/p>\n\n\n
        wg.Wait()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Go WaitGroup example<\/h3>\n\n\n\n
        The following example shows how to use a WaitGroup<\/code> to wait for all the goroutines to complete:<\/p>\n\n\n
        package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"sync\"<\/span>\n    \"time\"<\/span>\n)\n\nvar<\/span> wg sync.WaitGroup\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    \/\/ measure the execution time<\/span>\n    start := time.Now()\n    defer<\/span> func<\/span>()<\/span><\/span> {\n        elapsed := time.Since(start)\n        fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n    }()\n\n    wg.Add(3<\/span>)\n\n    go<\/span> task(\"Task 1\"<\/span>)\n    go<\/span> task(\"Task 2\"<\/span>)\n    go<\/span> task(\"Task 3\"<\/span>)\n\n    wg.Wait()\n\n    fmt.Println(\"Done\"<\/span>)\n}\n\nfunc<\/span> task<\/span>(name string<\/span>)<\/span><\/span> {\n    defer<\/span> wg.Done()\n\n    fmt.Println(name, \"started...\"<\/span>)\n    time.Sleep(1<\/span> * time.Second)\n    fmt.Println(name, \"finished\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Output:<\/p>\n\n\n
        Task 3<\/span> started...\nTask 1<\/span> started...\nTask 2<\/span> started...\nTask 2<\/span> finished\nTask 1<\/span> finished\nTask 3<\/span> finished\nDone\nIt took 1000<\/span> ms<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        The output shows two important things:<\/p>\n\n\n\n
          \n
        • First, goroutines did not execute in any order.<\/li>\n\n\n\n
        • Second, the program took roughly 1 second to complete. It’s three times faster than the synchronous program on our computer.<\/li>\n<\/ul>\n\n\n\n
          \"go<\/figure>\n\n\n\n
          How it works.<\/p>\n\n\n\n
          First, declare a variable with the type WaitGroup<\/code>:<\/p>\n\n\n
          var<\/span> wg sync.WaitGroup<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Second, set the WaitGroup<\/code>‘s counter to three to wait for three goroutines to complete before creating goroutines:<\/p>\n\n\n
          wg.Add(3<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Third, launch three goroutines:<\/p>\n\n\n
          go<\/span> task(\"Task 1\"<\/span>)\ngo<\/span> task(\"Task 2\"<\/span>)\ngo<\/span> task(\"Task 3\"<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Fifth, call the Wait()<\/code> function to wait for all the goroutines to complete:<\/p>\n\n\n
          wg.Wait()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Sixth, when executing the task()<\/code> function, decrement the counter of the WaitGroup<\/code> by one when it completes:<\/p>\n\n\n
          defer<\/span> wg.Done()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Goroutine practical example<\/h2>\n\n\n\n
          The following example shows how to use goroutines to check the status of multiple URLs:<\/p>\n\n\n
          package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"net\/http\"<\/span>\n    \"sync\"<\/span>\n)\n\nfunc<\/span> check<\/span>(url string<\/span>, wg *sync.WaitGroup)<\/span><\/span> {\n    defer<\/span> wg.Done()\n    _, err := http.Get(url)\n    if<\/span> err != nil<\/span> {\n        fmt.Printf(\"The %s is down\\n\"<\/span>, url)\n    } else<\/span> {\n        fmt.Printf(\"The %s is up\\n\"<\/span>, url)\n    }\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    var<\/span> wg sync.WaitGroup\n    urls := []string<\/span>{\n        \"https:\/\/www.google.com\"<\/span>,\n        \"https:\/\/www.bing.com\"<\/span>,\n        \"https:\/\/www.duckduckgo.com\/\"<\/span>,\n    }\n\n    wg.Add(len<\/span>(urls))\n\n    for<\/span> _, url := range<\/span> urls {\n        go<\/span> check(url, &wg)\n    }\n    wg.Wait()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          How it works.<\/p>\n\n\n\n
          Step 1. Define the check()<\/code> function that checks the status of a URL and displays whether the URL is up or down:<\/p>\n\n\n
          func<\/span> check<\/span>(url string<\/span>, wg *sync.WaitGroup)<\/span><\/span> {\n    defer<\/span> wg.Done()\n    _, err := http.Get(url)\n    if<\/span> err != nil<\/span> {\n        fmt.Printf(\"The %s is down\\n\"<\/span>, url)\n    } else<\/span> {\n        fmt.Printf(\"The %s is up\\n\"<\/span>, url)\n    }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Step 2. Define a variable for the WaitGroup<\/code> type<\/p>\n\n\n
          var<\/span> wg sync.WaitGroup<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Step 3. Declare and initialize a slice of strings, which hold a list of URLs to check:<\/p>\n\n\n
          urls := []string<\/span>{\n    \"https:\/\/www.google.com\"<\/span>,\n    \"https:\/\/www.bing.com\"<\/span>,\n    \"https:\/\/www.duckduckgo.com\/\"<\/span>,\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Step 4. Set the counter of the WaitGroup<\/code> to the size of the urls<\/code> slice:<\/p>\n\n\n
          wg.Add(len<\/span>(urls))<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Step 5. iterate over the URLs<\/code> and create each goroutine to check <\/p>\n\n\n
          for<\/span> _, url := range<\/span> urls {\n    go<\/span> check(url, &wg)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Step 6. Wait for all goroutines to complete:<\/p>\n\n\n
          wg.Wait()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Here’s the output of the program:<\/p>\n\n\n
          The https:\/\/www.google.com is up<\/span>\nThe https:\/\/www.bing.com is up<\/span>\nThe https:\/\/www.duckduckgo.com\/ is up<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
          Please note that the sequence of the URLs<\/code> may vary. <\/p>\n\n\n\n
          Summary<\/h2>\n\n\n\n
            \n
          • Goroutines are lightweight threads managed by Go runtime.<\/li>\n\n\n\n
          • Use go<\/code> keyword followed by a function call to run the function asynchronously.<\/li>\n\n\n\n
          • Use WaitGroup<\/code> to wait for a collection of goroutines to finish executing.<\/li>\n<\/ul>\n
            \n\t
            Was this tutorial helpful?<\/div>\n\t
            \n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t Yes <\/span>\n\t\t<\/button>\n\n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t No <\/span>\n\t\t<\/button>\n\t<\/div>\n\n\t
            \n\t\t
            \n\t\t\t
            <\/div>\n\t\t\t