1. 首页
  2. 未分类
  3. 正文

使用golang理解mysql的两阶段提交

2020年4月5日 303点热度 0人点赞 0条评论
图片

文章源于一个问题：如果我们现在有两个mysql实例，在我们要尽量简单地完成分布式事务，怎么处理？

场景重现

比如我们现在有两个数据库，mysql3306和mysql3307。这里我们使用docker来创建这两个实例：

  1. # mysql3306创建命令
  2. docker run -d -p 3306:3306 -v /Users/yjf/Documents/workspace/mysql-docker/my3306.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf -v /Users/yjf/Documents/workspace/mysql-docker/data3306:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql-3307 mysql:5.7

  4. # msyql3306的配置：
  5. [mysqld]
  6. pid-file    = /var/run/mysqld/mysqld.pid
  7. socket        = /var/run/mysqld/mysqld.sock
  8. datadir        = /var/lib/mysql
  9. server-id = 1
  10. log_bin = mysql-bin
  11. binlog_format = ROW
  12. expire_logs_days = 30

  14. # mysql3307创建命令
  15. docker run -d -p 3307:3306 -v /Users/yjf/Documents/workspace/mysql-docker/my3307.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf -v /Users/yjf/Documents/workspace/mysql-docker/data3307:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql-3307 mysql:5.7

  17. # msyql3307的配置：
  18. [mysqld]
  19. pid-file    = /var/run/mysqld/mysqld.pid
  20. socket        = /var/run/mysqld/mysqld.sock
  21. datadir        = /var/lib/mysql
  22. server-id = 2
  23. log_bin = mysql-bin
  24. binlog_format = ROW
  25. expire_logs_days = 30

在mysql3306中
我们有一个user表

  1. create table user (
  2.     id int,
  3.     name varchar(10),
  4.     score int
  5. );


  8. insert into user values(1, "foo", 10)

在mysql3307中，我们有一个wallet表。

  1. create table wallet (
  2.     id int,
  3.     money float 
  4. );


  7. insert into wallet values(1, 10.1)

我们可以看到，id为1的用户初始分数（score）为10，而它的钱，在wallet中初始钱（money）为10.1。

现在假设我们有一个操作，需要对这个用户进行操作：每次操作增加分数2，并且增加钱数1.2。

这个操作需要很强的一致性。

思考

两阶段提交

这里是一个分布式事务的概念，我们可以使用2PC的方法进行保证事务

图片

2PC的概念如图所示，引入一个资源协调者的概念，由这个资源协调者进行事务协调。

第一阶段，由这个资源协调者对每个mysql实例调用prepare命令，让所有的mysql实例准备好，如果其中由mysql实例没有准备好，协调者就让所有实例调用rollback命令进行回滚。如果所有mysql都prepare完成，那么就进入第二阶段。

第二阶段，资源协调者让每个mysql实例都调用commit方法，进行提交。

mysql里面也提供了分布式事务的语句XA。

用单个实例的事务行不行

等等，这个两阶段提交和我们的事务感觉也差不多，都是进行一次开始，然后执行，最后commit，mysql为什么还要专门定义一个xa的命令呢？于是我陷入了思考...

思考不如实操，于是我用golang写了一个使用mysql的事务实现的“两阶段提交”:

  1. package main

  3. import (
  4.     "database/sql"
  5.     "fmt"

  7.     _ "github.com/go-sql-driver/mysql"
  8.     "github.com/pkg/errors"
  9. )

  11. func main() {
  12.     var err error

  14.     // db1的连接
  15.     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")
  16.     if err != nil {
  17.         panic(err.Error())
  18.     }
  19.     defer db1.Close()

  21.     // db2的连接
  22.     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")
  23.     if err != nil {
  24.         panic(err.Error())
  25.     }
  26.     defer db2.Close()

  28.     // 开始前显示
  29.     var score int
  30.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  31.     fmt.Println("user1 score:", score)
  32.     var money float64
  33.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  34.     fmt.Println("wallet1 money:", money)

  36.     tx1, err := db1.Begin()
  37.     if err != nil {
  38.         panic(errors.WithStack(err))
  39.     }
  40.     tx2, err := db2.Begin()
  41.     if err != nil {
  42.         panic(errors.WithStack(err))
  43.     }

  45.     defer func() {
  46.         if err := recover(); err != nil {
  47.             fmt.Printf("%+v\n", err)
  48.             fmt.Println("=== call rollback ====")
  49.             tx1.Rollback()
  50.             tx2.Rollback()
  51.         }

  53.         db1.QueryRow("select score from user where id = 1").Scan(&score)
  54.         fmt.Println("user1 score:", score)
  55.         db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  56.         fmt.Println("wallet1 money:", money)
  57.     }()

  59.     // DML操作
  60.     if _, err = tx1.Exec("update user set score=score+2 where id =1"); err != nil {
  61.         panic(errors.WithStack(err))
  62.     }
  63.     if _, err = tx2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {
  64.         panic(errors.WithStack(err))
  65.     }

  67.     // panic(errors.New("commit before error"))

  69.     // commit
  70.     fmt.Println("=== call commit ====")
  71.     err = tx1.Commit()
  72.     if err != nil {
  73.         panic(errors.WithStack(err))
  74.     }

  76.     // panic(errors.New("commit db2 before error"))

  78.     err = tx2.Commit()
  79.     if err != nil {
  80.         panic(errors.WithStack(err))
  81.     }

  83.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  84.     fmt.Println("user1 score:", score)
  85.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  86.     fmt.Println("wallet1 money:", money)
  87. }

我这里已经非常小心地在defer中recover错误信息，并且执行了rollback命令。

如果我在commit命令之前的任意一个地方调用了 panic(errors.New("commit before error")) 那么命令就会进入到了rollback这里，就会把两个实例的事务都进行回滚。

图片

通过结果我们可以看到，分数和钱数都没有改变。这个是ok的。

但是如果我在db2的commit之前触发了panic，那么这个命令进入到了rollback中，但是db1已经commit了，db2还没有commit，这个时候会出现什么情况？

图片

非常可惜，我们看到了这里的score增长了，但是money没有增长，这个就说明无法做到事务一致性了。

回到mysql的xa

那么还要回归到2PC，mysql为2PC的实现增加了xa命令，那么使用这个命令我们能不能避免这个问题呢？

同样，我用golang写了一个使用xa命令的代码

  1. package main

  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "strconv"
  7.     "time"

  9.     _ "github.com/go-sql-driver/mysql"
  10.     "github.com/pkg/errors"
  11. )

  13. func main() {
  14.     var err error

  16.     // db1的连接
  17.     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")
  18.     if err != nil {
  19.         panic(err.Error())
  20.     }
  21.     defer db1.Close()

  23.     // db2的连接
  24.     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")
  25.     if err != nil {
  26.         panic(err.Error())
  27.     }
  28.     defer db2.Close()

  30.     // 开始前显示
  31.     var score int
  32.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  33.     fmt.Println("user1 score:", score)
  34.     var money float64
  35.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  36.     fmt.Println("wallet1 money:", money)

  38.     // 生成xid
  39.     xid := strconv.FormatInt(time.Now().Unix(), 10)
  40.     fmt.Println("=== xid:" + xid + " ====")
  41.     defer func() {
  42.         if err := recover(); err != nil {
  43.             fmt.Printf("%+v\n", err)
  44.             fmt.Println("=== call rollback ====")
  45.             db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  46.             db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  47.         }

  49.         db1.QueryRow("select score from user where id = 1").Scan(&score)
  50.         fmt.Println("user1 score:", score)
  51.         db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  52.         fmt.Println("wallet1 money:", money)
  53.     }()

  55.     // XA 启动
  56.     fmt.Println("=== call start ====")
  57.     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  58.         panic(errors.WithStack(err))
  59.     }
  60.     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  61.         panic(errors.WithStack(err))
  62.     }

  64.     // DML操作
  65.     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {
  66.         panic(errors.WithStack(err))
  67.     }
  68.     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {
  69.         panic(errors.WithStack(err))
  70.     }

  72.     // XA end
  73.     fmt.Println("=== call end ====")
  74.     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  75.         panic(errors.WithStack(err))
  76.     }
  77.     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  78.         panic(errors.WithStack(err))
  79.     }

  81.     // prepare
  82.     fmt.Println("=== call prepare ====")
  83.     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  84.         panic(errors.WithStack(err))
  85.     }
  86.     // panic(errors.New("db2 prepare error"))
  87.     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  88.         panic(errors.WithStack(err))
  89.     }

  91.     // commit
  92.     fmt.Println("=== call commit ====")
  93.     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  94.         panic(errors.WithStack(err))
  95.     }
  96.     // panic(errors.New("db2 commit error"))
  97.     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  98.         panic(errors.WithStack(err))
  99.     }

  101.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  102.     fmt.Println("user1 score:", score)
  103.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  104.     fmt.Println("wallet1 money:", money)
  105. }

首先看成功的情况：图片

一切完美。

如果我们在prepare阶段抛出panic，那么结果如下:

图片

证明在第一阶段出现异常是可以回滚的。

但是如果我们在commit阶段抛出panic:

图片

我们发现，这里的分数增加了，但是money却没有增加。

那么这个xa和单个事务有什么区别呢？我又陷入了深深的沉思...

xa的用法不对

经过在技术群（全栈神盾局）请教，讨论之后，发现这里对2pc的两个阶段理解还没到位，这里之所以分为两个阶段，是强调的是每个阶段都会持久化，就是第一个阶段完成了之后，每个mysql实例就把第一个阶段的请求实例化了，这个时候不管是mysql实例停止了还是其他问题，每次重启的时候都会重新回复这个commit。

我们把这个代码的rollback去掉，假设commit必须成功。

  1. package main

  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "strconv"
  7.     "time"

  9.     _ "github.com/go-sql-driver/mysql"
  10.     "github.com/pkg/errors"
  11. )

  13. func main() {
  14.     var err error

  16.     // db1的连接
  17.     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")
  18.     if err != nil {
  19.         panic(err.Error())
  20.     }
  21.     defer db1.Close()

  23.     // db2的连接
  24.     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")
  25.     if err != nil {
  26.         panic(err.Error())
  27.     }
  28.     defer db2.Close()

  30.     // 开始前显示
  31.     var score int
  32.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  33.     fmt.Println("user1 score:", score)
  34.     var money float64
  35.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  36.     fmt.Println("wallet1 money:", money)

  38.     // 生成xid
  39.     xid := strconv.FormatInt(time.Now().Unix(), 10)
  40.     fmt.Println("=== xid:" + xid + " ====")
  41.     defer func() {
  42.         if err := recover(); err != nil {
  43.             fmt.Printf("%+v\n", err)
  44.             fmt.Println("=== call rollback ====")
  45.             // db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  46.             // db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  47.         }

  49.         db1.QueryRow("select score from user where id = 1").Scan(&score)
  50.         fmt.Println("user1 score:", score)
  51.         db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  52.         fmt.Println("wallet1 money:", money)
  53.     }()

  55.     // XA 启动
  56.     fmt.Println("=== call start ====")
  57.     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  58.         panic(errors.WithStack(err))
  59.     }
  60.     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  61.         panic(errors.WithStack(err))
  62.     }

  64.     // DML操作
  65.     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {
  66.         panic(errors.WithStack(err))
  67.     }
  68.     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {
  69.         panic(errors.WithStack(err))
  70.     }

  72.     // XA end
  73.     fmt.Println("=== call end ====")
  74.     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  75.         panic(errors.WithStack(err))
  76.     }
  77.     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  78.         panic(errors.WithStack(err))
  79.     }

  81.     // prepare
  82.     fmt.Println("=== call prepare ====")
  83.     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  84.         panic(errors.WithStack(err))
  85.     }
  86.     // panic(errors.New("db2 prepare error"))
  87.     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  88.         panic(errors.WithStack(err))
  89.     }

  91.     // commit
  92.     fmt.Println("=== call commit ====")
  93.     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  94.         panic(errors.WithStack(err))
  95.     }
  96.     panic(errors.New("db2 commit error"))
  97.     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  98.         panic(errors.WithStack(err))
  99.     }

  101.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  102.     fmt.Println("user1 score:", score)
  103.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  104.     fmt.Println("wallet1 money:", money)
  105. }

图片

这个时候，我们停掉程序（停掉mysql的链接），使用 xa recover可以发现，db2的xa事务还留在db2中了。图片

我们在控制台直接调用 xa commit'1585644880' 还能继续把这个xa事务进行提交。

图片

这下money就进行了提交，又恢复了一致性。

所以呢，我琢磨了一下，我们写xa的代码应该如下：

  1. package main

  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "strconv"
  8.     "time"

  10.     _ "github.com/go-sql-driver/mysql"
  11.     "github.com/pkg/errors"
  12. )

  14. func main() {
  15.     var err error

  17.     // db1的连接
  18.     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")
  19.     if err != nil {
  20.         panic(err.Error())
  21.     }
  22.     defer db1.Close()

  24.     // db2的连接
  25.     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")
  26.     if err != nil {
  27.         panic(err.Error())
  28.     }
  29.     defer db2.Close()

  31.     // 开始前显示
  32.     var score int
  33.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  34.     fmt.Println("user1 score:", score)
  35.     var money float64
  36.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  37.     fmt.Println("wallet1 money:", money)

  39.     // 生成xid
  40.     xid := strconv.FormatInt(time.Now().Unix(), 10)
  41.     fmt.Println("=== xid:" + xid + " ====")
  42.     defer func() {
  43.         if err := recover(); err != nil {
  44.             fmt.Printf("%+v\n", err)
  45.             fmt.Println("=== call rollback ====")
  46.             db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  47.             db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))
  48.         }

  50.         db1.QueryRow("select score from user where id = 1").Scan(&score)
  51.         fmt.Println("user1 score:", score)
  52.         db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  53.         fmt.Println("wallet1 money:", money)
  54.     }()

  56.     // XA 启动
  57.     fmt.Println("=== call start ====")
  58.     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  59.         panic(errors.WithStack(err))
  60.     }
  61.     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {
  62.         panic(errors.WithStack(err))
  63.     }

  65.     // DML操作
  66.     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {
  67.         panic(errors.WithStack(err))
  68.     }
  69.     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {
  70.         panic(errors.WithStack(err))
  71.     }

  73.     // XA end
  74.     fmt.Println("=== call end ====")
  75.     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  76.         panic(errors.WithStack(err))
  77.     }
  78.     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {
  79.         panic(errors.WithStack(err))
  80.     }

  82.     // prepare
  83.     fmt.Println("=== call prepare ====")
  84.     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  85.         panic(errors.WithStack(err))
  86.     }
  87.     // panic(errors.New("db2 prepare error"))
  88.     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {
  89.         panic(errors.WithStack(err))
  90.     }

  92.     // commit
  93.     fmt.Println("=== call commit ====")
  94.     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  95.         // TODO: 尝试重新提交COMMIT
  96.         // TODO: 如果还失败，记录xid，进入数据恢复逻辑，等待数据库恢复重新提交
  97.         log.Println("xid:" + xid)
  98.     }
  99.     // panic(errors.New("db2 commit error"))
  100.     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {
  101.         log.Println("xid:" + xid)
  102.     }

  104.     db1.QueryRow("select score from user where id = 1").Scan(&score)
  105.     fmt.Println("user1 score:", score)
  106.     db2.QueryRow("select money from wallet where id = 1").Scan(&money)
  107.     fmt.Println("wallet1 money:", money)
  108. }

就是第二阶段的commit，我们必须设定它一定会“成功”，如果有不成功的情况，那么就需要记录下不成功的xid，有一个数据恢复逻辑，重新commit这个xid。来保证最终一致性。

binlog

其实我们使用binlog也能看出一些端倪

  1. # 这里的mysql-bin.0003替换成为你当前的log
  2. SHOW BINLOG EVENTS in 'mysql-bin.000003';
  1. ## XA的binlog
  2. | mysql-bin.000003 | 1967 | Anonymous_Gtid |         1 |        2032 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |
  3. | mysql-bin.000003 | 2032 | Query          |         1 |        2138 | XA START X'31353835363338363233',X'',1                                             |
  4. | mysql-bin.000003 | 2138 | Table_map      |         1 |        2190 | table_id: 108 (hade1.user)                                                         |
  5. | mysql-bin.000003 | 2190 | Update_rows    |         1 |        2252 | table_id: 108 flags: STMT_END_F                                                    |
  6. | mysql-bin.000003 | 2252 | Query          |         1 |        2356 | XA END X'31353835363338363233',X'',1                                               |
  7. | mysql-bin.000003 | 2356 | XA_prepare     |         1 |        2402 | XA PREPARE X'31353835363338363233',X'',1                                           |
  8. | mysql-bin.000003 | 2402 | Anonymous_Gtid |         1 |        2467 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |
  9. | mysql-bin.000003 | 2467 | Query          |         1 |        2574 | XA COMMIT X'31353835363338363233',X'',1



  13. ## 非xa的事务
  14. | mysql-bin.000003 | 2574 | Anonymous_Gtid |         1 |        2639 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |
  15. | mysql-bin.000003 | 2639 | Query          |         1 |        2712 | BEGIN                                                                              |
  16. | mysql-bin.000003 | 2712 | Table_map      |         1 |        2764 | table_id: 108 (hade1.user)                                                         |
  17. | mysql-bin.000003 | 2764 | Update_rows    |         1 |        2826 | table_id: 108 flags: STMT_END_F                                                    |
  18. | mysql-bin.000003 | 2826 | Xid            |         1 |        2857 | COMMIT /* xid=67 */

我们很明显可以看到两阶段提交中是有两个GTID的，生成一个GTID就代表内部生成一个事务，所以第一个阶段prepare结束之后，第二个阶段commit的时候就持久化了第一个阶段的内容，并且生成了第二个事务。当commit失败的时候，最多就是第二个事务丢失，第一个事务实际上已经保存起来了了（只是还没commit）。

而非xa的事务，只有一个GTID，在commit之前任意一个阶段出现问题，整个事务就全部丢失，无法找回了。所以这就是mysql xa命令的机制。

总结

看了一些资料，原来mysql从5.7之后才真正实现了两阶段的xa。当然这个两阶段方式在真实的工程中的使用其实很少的，xa的第一定律是避免使用xa。工程中会有很多方式来避免这种分库的事务情况。

不过，不妨碍掌握了mysql的xa，在一些特定的场合，我们也能完美解决问题。

图片

图片

Hi，我是轩脉刃，一个名不见经传码农，体制内的小愤青，躁动的骚年，2020年想坚持写一些学习/工作/思考笔记，谓之倒逼学习。欢迎关注个人公众号：轩脉刃的刀光剑影。

图片

MORE | 更多原创文章

① gorm日志模块源码解析

② 测试用例是开发人员最后一块遮羞布

③ mariaDB vs mysql的区别

④ 一次composer错误使用引发的思考

⑤ colly源码学习

⑥ 使用chan的时候选择对象还是指针

69020使用golang理解mysql的两阶段提交
标签： 暂无
最后更新：2020年4月5日

这个人很懒，什么都没留下

文章评论

Bootstrap 5入门指南 IDEA2022.3最新版永久激活教程（亲测有效） 转需！几百款中文永久版软件及安装方法（含百度云、天翼云下载） 50 万用户无人付费，Kite 停止开发！ 50w人白嫖！历经 8 年研发的 Python 代码补全神器 Kite 停止开发 有效的phpstorm正式版激活码，配合插件可永久破解！ 软件安装目录大全 Pycharm 2022 Pycharm激活码-PyCharm 2022.2.1中文版激活教程 （更新）Python编辑开发PyCharm pro 2022.2.4 for Mac 中文破解版下载（附激活码） Go语言爱好者周刊：第 170 期 — Gopher 图片集 GoLand 迎来五周年，同时发布 2022.3：有彩蛋 GoLand迎来五周年，2022.3发布 互联网摸鱼日报（2022-12-03） 《怪物猎人：崛起》即将登陆Xbox及PS平台
重磅：Go 1.18将移除用于泛型的constraints包 区块链解析：在不同的项目情况下有哈希推荐最为火热 JavaScript框架斗争激烈，后起之秀Vue.js还能撑多久？ 一个小插件让你的微信比别人更方便 谷歌员工抱怨工资低！CEO：好的，我改！ 独家 | 推荐系统不单单指推荐模型 Photoshop 2021 Win版已激活版软件ps安装包下载及安装教程 神器 ffmpeg —— 操作视频，极度舒适 Go语言爱好者周刊：第 142 期 —— 劳动节快乐 插件推荐 | SuperCopy，解除网页复制粘贴限制 吾爱破解大神！就是牛逼 前端开发者必备的12个工具 WordPress.com界面改版了，放弃了PHP改用JavaScript 【激活码】就你“心眼”多，快打开给我们瞧瞧~ PHP 8来了，首个测试版本
标签聚合
二手车 芯片 tiktok 前端 linux 科技 农业 开发 游戏 idea 2022 激活 软件 python 世界杯 m3u8 编程语言排行 网盘 caddy https web3 机器学习 表情包 xbox goland 2022
other

COPYRIGHT © 2022 编程网. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang