1. package main
    3. import (
    4.     "database/sql"
    5.     "fmt"
    6.     _ "github.com/go-sql-driver/mysql"
    7.     "runtime"
    8.     "sync"
    9.     "time"
    10. )
    12. // 定义任务队列
    13. var waitgroup sync.WaitGroup
    15. func xtgxiso(num int) {
    16.     //fmt.Println(num)
    17.     db, err := sql.Open("mysql", "root:Abcdef@123456@tcp(127.0.0.1:3306)/good_job?charset=utf8")
    18.     if err != nil {
    19.         fmt.Println(err)
    20.     }
    21.     defer db.Close()
    23.     rows, err := db.Query("select sleep(1) as a")
    24.     if err != nil {
    25.         fmt.Println(err)
    26.     }
    27.     defer rows.Close()
    29.     var a string
    30.     for rows.Next() {
    31.         err = rows.Scan(&a)
    32.         if err != nil {
    33.             fmt.Println(err)
    34.         } else {
    35.             //fmt.Println(a)
    36.         }
    37.     }
    38.     waitgroup.Done() //任务完成，将任务队列中的任务数量-1，其实.Done就是.Add(-1)
    39. }
    41. func main() {
    42.     //记录开始时间
    43.     start := time.Now()
    44.     //设置最大的可同时使用线程数
    45.     runtime.GOMAXPROCS(1)
    47.     for i := 1; i <= 10; i++ {
    48.         waitgroup.Add(1) //每创建一个goroutine，就把任务队列中任务的数量+1
    49.         // xtgxiso(i)
    50.         go xtgxiso(i)
    51.     }
    53.     waitgroup.Wait() //Wait()这里会发生阻塞，直到队列中所有的任务结束就会解除阻塞
    54.     //记录结束时间
    55.     end := time.Now()
    56.     //输出执行时间，单位为秒。
    57.     fmt.Println(end.Sub(start).Seconds())
    58. }
    1. // 顺序执行
    2. 10.1454757
    4. // 协程
    5. 1.0188696

    这个程序是执行十次”select sleep(1) as a“.如果是顺序阻塞执行的话，执行时间肯定是10s以上,而我们用的协程不会有这种情况。

    我们可以修改“runtime.GOMAXPROCS(1)”来设置最大可同时执行的线程数，对比结果发现，都是1s多点，有时多线程反而会比单线程慢些，这是为什么呢？

    这是因为这个程序是ＩＯ为主的，启用多线程反而有上下文切换，所以对于以涉及ＩＯ操作的主的程序启用多线程对于加速程序意义不大。

    runtime.GOMAXPROCS(1) 保证了mysql的操作（golang底层走的是非阻塞io）都在一个线程上执行，也就没有了cpu在多个线程之间来回调度。

    那么什么程序启用多线程呢？我们来看如下程序：

    1. package main
    3. import (
    4.     "fmt"
    5.     "runtime"
    6.     "sync"
    7.     "time"
    8. )
    10. // 定义任务队列
    11. var waitgroup2 sync.WaitGroup
    13. func xtgxiso2(num int) {
    14.     for i := 1; i <= 1000000000; i++ {
    15.         num = num + i
    16.         num = num - i
    17.         num = num * i
    18.         num = num / i
    19.     }
    20.     waitgroup2.Done() //任务完成，将任务队列中的任务数量-1，其实.Done就是.Add(-1)
    21. }
    23. func main() {
    25.     start := time.Now()
    27.     //设置最大的可同时使用的线程数
    28.     runtime.GOMAXPROCS(16)
    30.     for i := 1; i <= 10; i++ {
    31.         waitgroup2.Add(1) //每创建一个goroutine，就把任务队列中任务的数量+1
    32.         go xtgxiso2(i)
    33.     }
    35.     waitgroup2.Wait() //Wait()这里会发生阻塞，直到队列中所有的任务结束就会解除阻塞 线//记录结束时间
    36.     end := time.Now()
    37.     //输出执行时间，单位为秒。
    38.     fmt.Println(end.Sub(start).Seconds())
    39. }
    2. 4.7383003
    4. 0.7276601

    对比结果发现，多线程比单线程快，所以对于ＣＰＵ的运行上，多线程运行加速效果是很明显的.

    原文