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

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

场景重现

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

# mysql3306创建命令

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

# msyql3306的配置：

[mysqld]

pid-file     = /var/run/mysqld/mysqld.pid

socket          = /var/run/mysqld/mysqld.sock

datadir          = /var/lib/mysql

server-id = 1

log_bin = mysql-bin

binlog_format = ROW

expire_logs_days = 30

# mysql3307创建命令

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

# msyql3307的配置：

[mysqld]

pid-file     = /var/run/mysqld/mysqld.pid

socket          = /var/run/mysqld/mysqld.sock

datadir          = /var/lib/mysql

server-id = 2

log_bin = mysql-bin

binlog_format = ROW

expire_logs_days = 30

在mysql3306中

我们有一个user表

create table user (

    id int,

    name varchar(10),

    score int

);

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

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

create table wallet (

    id int,

    money float

);

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的事务实现的“两阶段提交”:

package main

import (

     "database/sql"

     "fmt"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     tx1, err := db1.Begin()

     if err != nil {

          panic(errors.WithStack(err))

     }

     tx2, err := db2.Begin()

     if err != nil {

          panic(errors.WithStack(err))

     }

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               tx1.Rollback()

               tx2.Rollback()

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // DML操作

     if _, err = tx1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = tx2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

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

     // commit

     fmt.Println("=== call commit ====")

     err = tx1.Commit()

     if err != nil {

          panic(errors.WithStack(err))

     }

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

     err = tx2.Commit()

     if err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

我这里已经非常小心地在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命令的代码

package main

import (

     "database/sql"

     "fmt"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

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

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

首先看成功的情况：

一切完美。

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

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

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

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

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

xa的用法不对

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

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

package main

import (

     "database/sql"

     "fmt"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               // db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               // db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     panic(errors.New("db2 commit error"))

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

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

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

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

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

package main

import (

     "database/sql"

     "fmt"

     "log"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          // TODO: 尝试重新提交COMMIT

          // TODO: 如果还失败，记录xid，进入数据恢复逻辑，等待数据库恢复重新提交

          log.Println("xid:" + xid)

     }

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

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          log.Println("xid:" + xid)

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

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

binlog

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

# 这里的mysql-bin.0003替换成为你当前的log

SHOW BINLOG EVENTS in 'mysql-bin.000003';


## XA的binlog

| mysql-bin.000003 | 1967 | Anonymous_Gtid |         1 |        2032 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2032 | Query          |         1 |        2138 | XA START X'31353835363338363233',X'',1                                             |

| mysql-bin.000003 | 2138 | Table_map      |         1 |        2190 | table_id: 108 (hade1.user)                                                         |

| mysql-bin.000003 | 2190 | Update_rows    |         1 |        2252 | table_id: 108 flags: STMT_END_F                                                    |

| mysql-bin.000003 | 2252 | Query          |         1 |        2356 | XA END X'31353835363338363233',X'',1                                               |

| mysql-bin.000003 | 2356 | XA_prepare     |         1 |        2402 | XA PREPARE X'31353835363338363233',X'',1                                           |

| mysql-bin.000003 | 2402 | Anonymous_Gtid |         1 |        2467 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2467 | Query          |         1 |        2574 | XA COMMIT X'31353835363338363233',X'',1

## 非xa的事务

| mysql-bin.000003 | 2574 | Anonymous_Gtid |         1 |        2639 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2639 | Query          |         1 |        2712 | BEGIN                                                                              |

| mysql-bin.000003 | 2712 | Table_map      |         1 |        2764 | table_id: 108 (hade1.user)                                                         |

| mysql-bin.000003 | 2764 | Update_rows    |         1 |        2826 | table_id: 108 flags: STMT_END_F                                                    |

| 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，在一些特定的场合，我们也能完美解决问题。

使用golang理解mysql的两阶段提交的更多相关文章

  1. 全网最牛X的！！！ MySQL两阶段提交串讲

    目录 一.吹个牛 二.事务及它的特性 三.简单看下两阶段提交的流程 四.两阶段写日志用意? 五.加餐:sync_binlog = 1 问题 六.如何判断binlog和redolog是否达成了一致 七. ...

  2. 聊一聊 MySQL 中的数据编辑过程中涉及的两阶段提交

    MySQL 数据库中的两阶段提交,不知道您知道不?这篇文章就简单的聊一聊 MySQL 数据库中的两阶段提交,两阶段提交发生在数据变更期间(更新.删除.新增等),两阶段提交过程中涉及到了 MySQL 数 ...

  3. flink-----实时项目---day07-----1.Flink的checkpoint原理分析 2. 自定义两阶段提交sink（MySQL） 3 将数据写入Hbase（使用幂等性结合at least Once实现精确一次性语义） 4 ProtoBuf

    1.Flink中exactly once实现原理分析 生产者从kafka拉取数据以及消费者往kafka写数据都需要保证exactly once.目前flink中支持exactly once的sourc ...

  4. MySQL binlog 组提交与 XA(两阶段提交)

    1. XA-2PC (two phase commit, 两阶段提交 ) XA是由X/Open组织提出的分布式事务的规范(X代表transaction; A代表accordant?).XA规范主要定义 ...

  5. MySQL binlog 组提交与 XA(分布式事务、两阶段提交)【转】

    概念: XA(分布式事务)规范主要定义了(全局)事务管理器(TM: Transaction Manager)和(局部)资源管理器(RM: Resource Manager)之间的接口.XA为了实现分布 ...

  6. MySQL binlog 组提交与 XA(两阶段提交)--1

    参考了网上几篇比较靠谱的文章 http://www.linuxidc.com/Linux/2015-11/124942.htm http://blog.csdn.net/woqutechteam/ar ...

  7. MySQL源码之两阶段提交

    在双1的情况下,两阶段提交的过程 环境准备:mysql 5.5.18, innodb 1.1 version配置: sync_binlog=1 innodb_flush_log_at_trx_comm ...

  8. MySQL两阶段提交

    参数介绍 innodb_flush_log_at_trx_commit 0: 每隔1s,系统后台线程刷log buffer,也就是把redo日志刷盘,这里会调用fsync,所以可能丢失最后1s的事务. ...

  9. 基于两阶段提交的分布式事务实现(UP-2PC)

    引言:分布式事务是分布式数据库的基础性功能,在2017年上海MySQL嘉年华(IMG)和中国数据库大会(DTCC2018)中作者都对银联UPSQL Proxy的分布式事务做了简要介绍,受限于交流形式难 ...

随机推荐

  1. JAVA Integer值的范围

    原文出处:http://hi.baidu.com/eduask%C9%BD%C8%AA/blog/item/227bf4d81c71ebf538012f53.html package com.test ...

  2. Vmware安装的linux系统开机黑屏，关闭显示虚拟机忙怎么怎么解决？

    在vm虚拟机中,可能会遇到打开一台主机直接黑屏,而且无法关闭,关闭会显示虚拟机繁忙这种情况,如下图: 一般是因为没有正常关机或者操作不当导致的   对此,解决办法一般有两种 第一种方法: 1.重启电脑 ...

  3. Python基础-两个乒乓球队进行比赛，各出三人。

    两个乒乓球队进行比赛,各出三人.甲队为a,b,c三人,乙队为x,y,z三人.已抽签决定比赛名单.有人向队员打听比赛的名单.a说他不和x比,c说他不和x,z比,请编程序找出三队赛手的名单. L1 = [ ...

  4. .Net Core 为 x86 和 x64 程序集编写 AnyCPU 包装

    前言 这几天研究了一下 vJoy 这个虚拟游戏手柄驱动,感觉挺好玩的.但是使用时发现一个问题,C# SDK 中的程序集被分为 x86 和 x64 两个版本,如果直接在 AnyCPU 平台编译运行就有隐 ...

  5. UICollectionViewCell设置阴影

    //@mg:masksToBounds必须为NO否者阴影没有效果 // cell.layer.masksToBounds = NO; cell.layer.contentsScale = [UIScr ...

  6. 编译putty 源码去掉 Are you sure you want to close this session? 提示

    0, 为什么要编译 putty ?在关闭窗口的时候,会弹出一个 Are you sure you want to close this session?要把这个去掉.当然也可以用 OD 之类的来修改. ...

  7. Mathtype快捷键&小技巧

    Mathtype使用方便,能插入到Office等编辑器中,Latex公式在某些地方更加通用,如网页和书籍. 1. Mathtype简介 数学公式编辑器(MathType)是一款专业的数学公式编辑工具, ...

  8. 初识JVM：（一）JVM工作原理和流程

    本文主要参考:http://blog.csdn.net/CSDN_980979768/article/details/47281037?locationNum=7&fps=1 声明:主要用于个 ...

  9. 把 GitHub 放入口袋，“开箱”官方客户端

    GitHub 2019 开发者大会说要出的客户端,今天(2020.3.18)终于放出了下载.之前如果登记过的小伙伴应该也和我一样收到了下面样子的邮件: 好了,那么接下来我们就来"开箱&quo ...

  10. Angular介绍

    Angulay介绍 1.介绍:是一个用于Html和TypeScript构建客户端应用平台与框架.Angular 本身就是用 TypeScript 写成的.基本构造块是 NgModule,它为组件提供了 ...