go 语言中mysql操作200万数据时应该如何写？

在写一个将 discuzx 的 post 数据的 bbcode 转换成 html 的功能。
但是转换过程中，越到后面，越卡了。
本来想学学并发的，无奈不会啊。。。太菜了。
注释掉的是想要弄的。。。

求个解决方案。代码如下。

package main

import (
    "database/sql"
    "fmt"
    "github.com/frustra/bbcode"
    _ "github.com/go-sql-driver/mysql"
    //"time"
    //"runtime"
    "strconv"
)

const (
    XnFromPost = "bbs_post"
    XnTopost   = "bbs_post"
    DxFromPost = "pre_forum_post"
)

type Hostinfo struct {
    DBUser,
    DBPassword,
    DBname,
    DBHost,
    DBPort,
    DBChar string
}

type post struct {
    pid     int
    message string
}

var OldDB, NewDB *sql.DB

/**
  设置数据库，并连接数据库
*/
func SetDB() (olddata, newdata *sql.DB) {
    var localhost, remotehost Hostinfo

    localhost = Hostinfo{
        "root",
        "123456",
        "xiuno",
        "",
        "3306",
        "utf8",
    }

    remotehost = Hostinfo{
        "root",
        "123456",
        "gxvtc",
        "",
        "3306",
        "utf8",
    }

    olddata, _ = connMysql(&localhost)
    newdata, _ = connMysql(&remotehost)

    return olddata, newdata
}

/**
连接数据库
*/
func connMysql(host *Hostinfo) (*sql.DB, error) {
    //db, err := sql.Open("mysql", "root:123456@/"+dbs+"?charset=utf8")
    if host.DBHost != "" {
        host.DBHost = "tcp(" + host.DBHost + ":" + host.DBPort + ")"
        fmt.Println(host.DBHost)
    }

    db, err := sql.Open("mysql", host.DBUser+":"+host.DBPassword+"@"+host.DBHost+"/"+host.DBname+"?charset="+host.DBChar)
    return db, err
}

func main() {
    OldDB, NewDB = SetDB()
    defer OldDB.Close()
    defer NewDB.Close()
    updatePost()
}

func updatePost() {
    const total = 100

    //selectPost := "SELECT pid,message FROM " + XnFromPost + " ORDER BY pid ASC LIMIT 10"
    selectPost := "SELECT pid,message FROM " + DxFromPost + " ORDER BY pid ASC "
    /*
        Data, err := OldDB.Query(selectPost)
        if err != nil {
            fmt.Println(err.Error())
        }*/
    fmt.Println(selectPost)

    updatePost := "UPDATE " + XnTopost + " SET message = ? WHERE pid = ? limit 1"
    fmt.Println(updatePost)
    stmt, err := OldDB.Prepare(updatePost)
    //insertPost := "INSERT INTO " + XnTopost + " (message,pid) VALUES (?,?)"
    //fmt.Println(insertPost)
    //stmt, err := OldDB.Prepare(insertPost)

    if err != nil {
        fmt.Println(err.Error())
    }

    //mypost := make(map[int]post)

    i := 0
    for {
        tmpNum := i * total

        i++
        tmpSQL := selectPost + " LIMIT " + strconv.Itoa(tmpNum) + "," + strconv.Itoa(total)
        fmt.Println(tmpSQL)
        Data, err := NewDB.Query(tmpSQL)
        //Data, err := NewDB.Query(tmpSQL)
        if err != nil {
            fmt.Println(err.Error())
        }

        tag := false
        //使用并发的方式
        for Data.Next() {
            tag = true
            var pid int
            var msg string
            Data.Scan(&pid, &msg)
            fmt.Println(pid)

            //bbcode转码html
            compiler := bbcode.NewCompiler(true, true)
            msg = compiler.Compile(msg)
            //mypost[pid] = post{pid, msg}
            _, err = stmt.Exec(msg, pid)
            if err != nil {
                fmt.Println("pid: ", pid, err.Error())
            }
        }

        if tag == false {
            fmt.Println("没有数据了...")
            break
        }

    }

    /*
       //直接查找并更新
           for Data.Next() {
               var pid int
               var msg string
               Data.Scan(&pid, &msg)

               //bbcode转码html
               compiler := bbcode.NewCompiler(true, true)
               msg = compiler.Compile(msg)

               mypost[pid] = post{pid, msg}
               //fmt.Println(mypost)
               fmt.Println(pid)

               _, err = stmt.Exec(msg, pid)
               if err != nil {
                   fmt.Println("pid: ", pid, err.Error())
               }
           }
    */

    /*
            //使用并发的方式
            for Data.Next() {
                var pid int
                var msg string
                Data.Scan(&pid, &msg)

                //bbcode转码html
                compiler := bbcode.NewCompiler(true, true)
                msg = compiler.Compile(msg)
                mypost[pid] = post{pid, msg}
            }

        runtime.GOMAXPROCS(runtime.NumCPU())
        c := make(chan post)
        for _, v := range mypost {
            go ShowMsg(c, v)
            /*
                go func() {
                    fmt.Println(v.pid)
                    c <- v.pid
                }()
                <-c
            //time.Sleep(2 * time.Second)
            //fmt.Println(v.pid)
        }

        for _, _ = range mypost {
            fmt.Println(&c)
            <-c
        } */

}

func ShowMsg(c chan post, mypost post) {
    //fmt.Println(mypost.pid)
    c <- mypost
}

由于我实在没有耐心看完你的代码,而且很多东西都还要你自己去实践, 这里我简单说一下我的方案, 希望能给你指明方向; 当然我也可能有理解错误,如果谁发现错误,请及时告知.

先说明几个比较重要的概念和前提知识:

golang的协程对应的是实际操作系统线程, routine之间是独立的
使用go关键字调用了一个函数后, 只是新建了另外一个新的线程
指定了cpu number之后go才真正使用多核cpu, goroutine才真正被并行调度;
使用无缓冲channel就像是握手,必须同时有写有读才能继续执行
channel使用完毕之后需要进行关闭, 否则会有内存泄露
channel可以试用range进行读取

好了, 上面比较枯燥, 下面是我按照我的代码开始给你讲解清楚你需要注意的问题:

/* 正确创建合适数量的goroutine */

#建议创建routine的方式类似这样, 根据CPU数量创建合适的线程
runtime.GOMAXPROCS(runtime.NumCPU())
for i:=0; i < runtime.NumCPU()+2; i++ {
    go func(id int) {
        fmt.Printf("new routine id(%d)\n", i)
    }(i)
}

#你的创建方式是错误的, 根据你的数据数量创建等数量的线程, 每个线程只处理一个数据
for _, v := range mypost {
    go ShowMsg(c, v)
}

好, 创建了合适的线程之后,我们开始分析这些线程的执行, 上面for循环的代码所在的线程(routine)我们可以称之为main routine, 因为它是第一个routine; go后面调用的匿名函数则并发执行了内部逻辑, main routine现在不知道哪个routine先执行完毕, 也就更不知道它们合适全部执行完毕, 作为一个合格的程序员,必须考虑清楚他们之间的先后顺序;

import "sync"
/* 正确管理routine的生命周期, 防止死锁 */
var barrier sync.WaitGroup /* 使用WaitGroup管理自己启动的多个线程 */

for i:=0; i < runtime.NumCPU()+2; i++ {
    barrier.Add(1)      /* 总数加1 */
    go func(id int) {
        fmt.Printf("new routine id(%d)\n", i)
        barrier.Done()  /* 总数减1 */
    }(i)
}

go func() {
    barrier.Wait() /* 等待上面的所有routine结束(总数变为0) */
    #由于Wait会卡死, 为了不影响main routine的执行, 这里将它单独放在一个routine中
}()

OK了, 现在routine全部在掌握之中, 下面就可以考虑如何让它们替我工作了!而我们要做的就是利用channel传递数据进去, 让routine通过routine接收数据并并发处理.

#假想的任务: 多线程执行1到100得加法!
var barrier sync.WaitGroup /* 使用WaitGroup管理自己启动的多个线程 */
cin  := make(chan int)
cout := make(chan int)
#因为cin无缓冲的(有缓冲也不可能容纳全部100个数据), 所以增加新的routine往其中写数据, 保证main routine不卡死, 可以调用起来后面的for循环, 消耗数据.
go func() {
    for i:=1; i <= 100; i++ {
        cin<-i
    }
    Close(cin)
}

for i:=0; i < runtime.NumCPU()+2; i++ {
    barrier.Add(1)      /* 总数加1 */
    go func() {
        sum := 0
        # for循环, 每个routine处理cin中读取的多个(不是全部100个)数据处理
        for x := range cin {
            sum += x
        }
        cout<-sum
        barrier.Done()  /* 总数减1 */
    }()
}

go func() {
    #由于Wait会卡死, 为了不影响main routine,这里将它单独放在一个routine中.
    barrier.Wait() /* 等待上面的所有routine结束(总数变为0) */
    Close(cout) #全部运算routine都结束了, 再也不会写cout, 关闭channel
}()

var totalSum int := 0
for s := cout { #main routine读取各个routine的结果,做最终的统计
    totalSum += s
}
fmt.Println(totalSum)

注: 以上代码并未严格测试, 只是为了说明我的方案, 呵呵好累. 给个辛苦分..

先搞清楚这个问题到底是讨论数据库处理能力还是golang 如何利用多核进行多并发？

题主要解决的：越到后来越慢？到底是慢在哪？ mysql？还是你的go程序？

慢的是golang对CPU的使用（不可能）？还是mysql硬盘IO？

基本可以肯定是你的mysql硬盘IO卡了。

操作200万条数据的话，我的做法是做一个线程池，然后每次具体的插入指定条记录的数据。这样多个线程协同工作，还可以缓解数据库IO的压力。

【热门文章】