皮皮网

1.如何减轻MySQL数据库的权源权源工作压力
2.MySQL 核心模块揭秘 | 13 期 | 回滚到 savepoint
3.优化mysql 多大内存 centos6
4.如何杀掉空闲事务
5.MySQL 核心模块揭秘 | 12 期 | 创建 savepoint
6.tron货币什么情况

如何减轻MySQL数据库的工作压力

       当使用MySQL数据库的网站访问量越来越大的时候，它的码授码下压力也会越来越大，那么如何给MySQL数据库减压呢？那就是权源权源优化！ 单机MySQL的码授码下优化有三种方法。分别是权源权源：一、服务器物理硬件的码授码下源码生成configure优化；二、MySQL安装时的权源权源编译优化；三、自身配置文件my.cnf的码授码下优化。一、权源权源服务器物理硬件的码授码下优化１、磁盘寻道能力(磁盘I/O) 是权源权源制约MySQL性能的最大因素之一，建议使用RAID1+0磁盘阵列，码授码下另外最好不要尝试使用RAID-5，权源权源因为MySQL在RAID-5磁盘阵列上的码授码下效率实际上并不是很快;２、CPU也很重要，权源权源对于MySQL应用，推荐使用DELL R，E @2.GHz(4 core)* 2或跟这个处理能力差不多的也行。 ３、物理内存，物理内存对于一台使用MySQL的Database Server来说，服务器内存建议不要小于2GB，推荐使用4GB以上的物理内存。二、MySQL安装时的编译优化 建议采取编译安装的方法，这样性能上有较大提升，服务器系统建议用bit的Centos5.5，源码包的编译参数会默认以Debgu模式生成二进制代码，而Debug模式给MySQL带来的性能损失是比较大的，所以当我们编译准备安装的产品代码时，一定不要忘记使用“—without-debug”参数禁用Debug模式。 而如果把—with-mysqld-ldflags和—with-client-ldflags二个编译参数设置为—all-static的话，可以告诉编译器以静态方式编译和编译结果代码得到最高的性能。使用静态编译和使用动态编译的代码相比，性能差距可能会达到5%至%之多。三、自身配置文件my.cnf的优化 当解决了上述服务器硬件制约因素后，让我们看看MySQL自身的优化是如何操作的。对 MySQL自身的优化主要是对其配置文件my.cnf中的各项参数进行优化调整。下面我们介绍一些对性能影响较大的jquery dialog源码参数。下面，我们根据以上硬件配置结合一份已经优化好的my.cnf进行说明：#vim /etc/my.cnf以下只列出my.cnf文件中[mysqld]段落中的内容，其他段落内容对MySQL运行性能影响甚微，因而姑且忽略。[mysqld] port = serverid = 1 socket = /tmp/mysql.sockskip-locking#避免MySQL的外部锁定，减少出错几率增强稳定性。skip-name-resolve#禁止MySQL对外部连接进行DNS解析，使用这一选项可以消除MySQL进行DNS解析的时间。但需要注意，如果开启该选项，则所有远程主机连接授权都要使用IP地址方式，否则MySQL将无法正常处理连接请求!back_log = #back_log参数的值指出在MySQL暂时停止响应新请求之前的短时间内多少个请求可以被存在堆栈中。 如果系统在一个短时间内有很多连接，则需要增大该参数的值，该参数值指定到来的TCP/IP连接的侦听队列的大小。不同的操作系统在这个队列大小上有它自 己的限制。 试图设定back_log高于你的操作系统的限制将是无效的。默认值为。对于Linux系统推荐设置为小于的整数。key_buffer_size = M#key_buffer_size指定用于索引的缓冲区大小，增加它可得到更好的索引处理性能。对于内存在4GB左右的服务器该参数可设置为M或M。注意：该参数值设置的过大反而会是服务器整体效率降低!max_allowed_packet = 4M thread_stack = K table_cache = K sort_buffer_size = 6M#查询排序时所能使用的缓冲区大小。注意：该参数对应的分配内存是每连接独占，如果有个连接，那么实际分配的总共排序缓冲区大小为 × 6 = MB。所以，对于内存在4GB左右的服务器推荐设置为6-8M。read_buffer_size = 4M#读查询操作所能使用的缓冲区大小。和sort_buffer_size一样，该参数对应的分配内存也是每连接独享。join_buffer_size = 8M#联合查询操作所能使用的缓冲区大小，和sort_buffer_size一样，该参数对应的分配内存也是每连接独享。myisam_sort_buffer_size = M table_cache = thread_cache_size = query_cache_size = M#指定MySQL查询缓冲区的大小。可以通过在MySQL控制台观察，如果Qcache_lowmem_prunes的值非常大，则表明经常出现缓冲不够 的情况;如果Qcache_hits的值非常大，则表明查询缓冲使用非常频繁，tp房产源码如果该值较小反而会影响效率，那么可以考虑不用查询缓冲;Qcache_free_blocks，如果该值非常大，则表明缓冲区中碎片很多。tmp_table_size = M max_connections = #指定MySQL允许的最大连接进程数。如果在访问论坛时经常出现Too Many Connections的错误提 示，则需要增大该参数值。max_connect_errors = wait_timeout = #指定一个请求的最大连接时间，对于4GB左右内存的服务器可以设置为5-。thread_concurrency = 8#该参数取值为服务器逻辑CPU数量*2，在本例中，服务器有2颗物理CPU，而每颗物理CPU又支持H.T超线程，所以实际取值为4*2=8;这个目前也是双四核主流服务器配置。skip-networking#开启该选项可以彻底关闭MySQL的TCP/IP连接方式，如果WEB服务器是以远程连接的方式访问MySQL数据库服务器则不要开启该选项!否则将无法正常连接!table_cache=#物理内存越大,设置就越大.默认为,调到-最佳innodb_additional_mem_pool_size=4M#默认为2Minnodb_flush_log_at_trx_commit=1#设置为0就是等到innodb_log_buffer_size列队满后再统一储存,默认为1innodb_log_buffer_size=2M#默认为1Minnodb_thread_concurrency=8#你的服务器CPU有几个就设置为几,建议用默认一般为8key_buffer_size=M#默认为，调到最佳tmp_table_size=M#默认为M，调到-最挂read_buffer_size=4M#默认为Kread_rnd_buffer_size=M#默认为Ksort_buffer_size=M#默认为Kthread_cache_size=#默认为query_cache_size=M 另外很多情况需要具体情况具体分析１、如果Key_reads太大，则应该把my.cnf中Key_buffer_size变大，保持Key_reads/Key_read_requests至少1/以上，越小越好。２、如果Qcache_lowmem_prunes很大，就要增加Query_cache_size的值。 通过参数设置进行性能优化或多或少可以带来性能的提升，但效果不一定会很突出。

MySQL 核心模块揭秘 | 期 | 回滚到 savepoint

       深入理解 MySQL，了解如何实现部分回滚操作。本文由技术专家操盛春撰写，他在公众号『一树一溪』分享 MySQL 和 OceanBase 源码研究。本文基于 MySQL 8.0.，InnoDB 存储引擎，探讨核心模块的工作原理。

       首先，我们创建测试表并插入数据。关键操作分为四个阶段，编号为 SQL 1 至 SQL 4，其中 SQL 4 是年终抽奖源码讨论焦点。SQL 2 和 SQL 3 分别产生 undo 日志 0 和 1。

       当执行事务时，产生的 binlog 日志在 trx cache 中。回滚整个事务时，需要清除这些日志。然而，实际操作中，binlog 回滚步骤看似简单，却并未执行真正清除，只是为后续的 InnoDB 回滚做准备。

       InnoDB 回滚是关键环节，它会根据 undo 日志执行反向操作，恢复事务影响的数据。以 SQL 为例，会从最新的 undo 日志开始回滚，逐条执行反向操作，包括记录的删除。

       回滚后，事务的执行状态需要通过提交事务来更新。这不同于 commit 语句，因为回滚操作已经改变了数据，即使从逻辑上看恢复了原样，也需要将 InnoDB 中的修改正式提交。

       trx cache 中的 binlog 日志会在 InnoDB 回滚完成后进行清除，这个过程涉及内存 buffer 和磁盘临时文件。binlog 回滚步骤延迟到这个阶段，是因为在事务提交前，binlog 日志并不需要写入持久化存储。

       总结起来，MySQL 的部分回滚包括：无实际动作的 binlog 回滚，执行 InnoDB 回滚恢复数据，然后提交 InnoDB 事务，最后清理 trx cache 中的临时 binlog。如果你对文中内容有疑问，欢迎留言交流。

       对于 SQL 质量管理，如需更多工具支持，可以了解 SQLE，一个覆盖开发到生产环境的农场 vb源码 SQL 管理平台，提供流程自动化和数据质量管理功能。

优化mysql 多大内存 centos6

       ä¸€ã€mysql的优化思路

       mysql的优化分为两方面：

       1. 服务器使用前的优化

       2. 服务使用中的优化

       äºŒã€mysql的基础优化步骤

       1. 硬件级优化

       ï¼ˆ1）. 最好mysql自己使用一台物理服务器

       ï¼ˆ2）. 内存和CPU方面，根据需求给予mysql服务器足够大的内存和足够多的CPU核数

       (3). 避免使用Swap交换分区–交换时从硬盘读取的它的速度很慢，有的DBA安装系统时就不装swap分区

       ï¼ˆ4）. 如果是mysql主库，硬盘可以选用比较好的高速硬盘，系统用SSD固态硬盘，数据盘用sas替代sata硬盘，将操作系统和数据分区分开

       ï¼ˆ5）. mysql产生的日志与数据库也放到不同的磁盘分区上面

       ï¼ˆ6）. mysql数据库硬盘格式化时，可以指定更小的硬盘块

       ï¼ˆ7）. 关于做RAID方面，主库尽量做成RAID，既提高了数据的读写速度也提到了数据的安全性

       ï¼ˆ8). 服务器双线双电，保障服务器运行稳定，不会因为突然断电影响业务和损坏磁盘数据

       2. mysql数据库设计优化

       ï¼ˆ1). 根据需求选择正确的存储引擎，比如说读的特别猛就用MySAM,如果对事务性要求高就用InnoDB

       (2). 设置合理的字段类型和字段长度,比如说你这个字段就多个字段你设置成VARCHAR()就是对磁盘空间的浪费

       ï¼ˆ3）. 默认值尽可能的使用 NOT NULL，如果空值太多对mysql的查询会有影响，尤其是在查询语句编写上面

       ï¼ˆ4）. 尽量少的使用VARCHAR，TEXT，BLOB这三个字段

       ï¼ˆ5）. 添加适当索引(index) [四种: 普通索引、主键索引、唯一索引unique、全文索引]

       ï¼ˆ6）. 不要滥用索引，大表索引，小表不索引

       ï¼ˆ7）. 表的设计合理化(符合3NF)

       3. mysql配置参数的优化

       è¿™é‡Œæ˜¯mysql5.5版本的配置文件

       vi my.cnf

       [client]

       port = #mysql客户端连接时的默认端口

       socket = /tmp/mysql.sock #与mysql服务器本地通信所使用的socket文件路径

       default-character-set = utf8 #指定默认字符集为utf8

       [mysql]

       no-auto-rehash #auto-rehash是自动补全的意思，就像我们在linux命令行里输入命令的时候，使用tab键的功能是一样的，这里是默认的不自动补全

       default-character-set = utf8 #指定默认字符集为utf8

       [mysqld]

       user = mysql

       port =

       character-set-server = utf8 #设置服务器端的字符编码

       socket = /tmp/mysql.sock

       basedir = /application/mysql

       datadir = /mysqldata

       skip-locking #避免MySQL的外部锁定，减少出错几率增强稳定性。

       open_files_limit = #MySQL打开的文件描述符限制，默认最小;当open_files_limit没有被配置的时候，比较max_connections*5和ulimit -n的值，哪个大用哪个，当open_file_limit被配置的时候，比较open_files_limit和max_connections*5的值，哪个大用哪个。

       back_log = #back_log参数的值指出在MySQL暂时停止响应新请求之前的短时间内多少个请求可 以被存在堆栈中。 如果系统在一个短时间内有很多连接，则需要增大该参数的值，该参数值指定到来的TCP/IP连接的侦听队列的大小。不同的操作系统在这个队列大小上有它自 己的限制。 试图设back_log高于你的操作系统的限制将是无效的。默认值为。对于Linux系统推荐设置为小于的整数。

       max_connections = #MySQL的最大连接数，如果服务器的并发连接请求量比较大，建议调高此值，以增加并行连接数量，当然这建立在机器能支撑的情况下，因为如果连接数越多， 介于MySQL会为每个连接提供连接缓冲区，就会开销越多的内存，所以要适当调整该值，不能盲目提高设值。可以过’conn%’通配符查看当前状态的连接 数量，以定夺该值的大小。

       max_connect_errors = #对于同一主机，如果有超出该参数值个数的中断错误连接，则该主机将被禁止连接。如需对该主机进行解禁，执行：FLUSH HOST。

       table_cache = #物理内存越大,设置就越大.默认为,调到-最佳

       external-locking = FALSE #使用–skip-external-locking MySQL选项以避免外部锁定。该选项默认开启

       max_allowed_packet =8M #设置最大包,限制server接受的数据包大小，避免超长SQL的执行有问题 默认值为M，当MySQL客户端或mysqld服务器收到大于max_allowed_packet字节的信息包时，将发出“信息包过大”错误，并关闭连接。对于某些客户端，如果通信信息包过大，在执行查询期间，可能会遇“丢失与MySQL服务器的连接”错误。默认值M。

       sort_buffer_size = 6M #用于表间关联缓存的大小，查询排序时所能使用的缓冲区大小。注意：该参数对应的分配内存是每连接独占，如果有个连接，那么实际分配的总共排序缓冲区大小为 × 6 ＝ MB。所以，对于内存在4GB左右的服务器推荐设置为6-8M。

       join_buffer_size = 6M #联合查询操作所能使用的缓冲区大小，和sort_buffer_size一样，该参数对应的分配内存也是每连接独享。

       thread_cache_size = #服务器线程缓存这个值表示可以重新利用保存在缓存中线程的数量,当断开连接时如果缓存中还有空间,那么客户端的线程将被放到缓存中,如果线程重新被请求， 那么请求将从缓存中读取,如果缓存中是空的或者是新的请求，那么这个线程将被重新创建,如果有很多新的线程，增加这个值可以改善系统性能.通过比较 Connections 和 Threads_created 状态的变量，可以看到这个变量的作用

       thread_concurrency = 8 #设置thread_concurrency的值的正确与否, 对mysql的性能影响很大, 在多个cpu(或多核)的情况下，错误设置了thread_concurrency的值, 会导致mysql不能充分利用多cpu(或多核), 出现同一时刻只能一个cpu(或核)在工作的情况。thread_concurrency应设为CPU核数的2倍. 比如有一个双核的CPU, 那么thread_concurrency的应该为4; 2个双核的cpu, thread_concurrency的值应为8，属重点优化参数

       query_cache_size = 2M #指定MySQL查询缓冲区的大小，在数据库写入量或是更新量也比较大的系统，该参数不适合分配过大。而且在高并发，写入量大的系统，建系把该功能禁掉。

       query_cache_limit = 1M #默认是4KB，设置值大对大数据查询有好处，但如果你的查询都是小数据查询，就容易造成内存碎片和浪费

       query_cache_min_res_unit = 2k #MySQL参数中query_cache_min_res_unit查询缓存中的块是以这个大小进行分配的，使用下面的公式计算查询缓存的平均大小，根据计算结果设置这个变量，MySQL就会更有效地使用查询缓存，缓存更多的查询，减少内存的浪费。

       default_table_type = InnoDB #默认表的引擎为InnoDB

       thread_stack = K #限定用于每个数据库线程的栈大小。默认设置足以满足大多数应用transaction_isolation = READ-COMMITTED #设定默认的事务隔离级别.可用的级别如下:

       READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE,1.READ UNCOMMITTED-读未提交2.READ COMMITTE-读已提交3.REPEATABLE READ -可重复读4.SERIALIZABLE -串行

       tmp_table_size = M #tmp_table_size 的默认大小是 M。如果一张临时表超出该大小，MySQL产生一个 The table tbl_name is full 形式的错误，如果你做很多高级 GROUP BY 查询，增加 tmp_table_size 值。

       max_heap_table_size = M #内存表，内存表不支持事务，内存表使用哈希散列索引把数据保存在内存中，因此具有极快的速度，适合缓存中小型数据库，但是使用上受到一些限制

       long_query_time = 1 #记录时间超过1秒的查询语句

       log_long_format #

       log-error = /logs/error.log #开启mysql错误日志，该选项指定mysqld保存错误日志文件的位置

       log-slow-queries = /logs/slow.log #慢查询日志文件路径

       pid-file = /pids/mysql.pid

       log-bin = /binlog/mysql-bin #binlog日志位置以及binlog的名称

       relay-log = /relaylog/relay-bin #relaylog日志位置以名称

       binlog_cache_size = 1M #binlog_cache_size 就是满足两点的：一个事务，在没有提交（uncommitted）的时候，产生的日志，记录到Cache中；等到事务提交（committed）需要提交的时候，则把日志持久化到磁盘，默认是K。

       max_binlog_cache_size = M #binlog缓存最大使用的内存

       max_binlog_size = 2M #一个binlog日志的大小

       expire_logs_days = 7 #保留7天的binlog

       key_buffer_size = M #索引缓存大小: 它决定了数据库索引处理的速度，尤其是索引读的速度

       read_buffer_size = M #MySql读入缓冲区大小。对表进行顺序扫描的请求将分配一个读入缓冲区，MySql会为它分配一段内存缓冲区。read_buffer_size变量控制这一缓冲区的大小。如果对表的顺序扫描请求非常频繁，并且你认为频繁扫描进行得太慢，可以通过增加该变量值以及内存缓冲区大小提高其性能

       read_rnd_buffer_size = 2M #MySQL的随机读缓冲区大小。当按任意顺序读取行时(例如，按照排序顺序)，将分配一个随机读缓存区。进行排序查询时，MySQL会首先扫描一遍该缓冲，以避免磁盘搜索，提高查询速度，如果需要排序大量数据，可适当调高该值。但MySQL会为每个客户连接发放该缓冲空间，所以应尽量适当设置该值，以避免内存开销过大

       bulk_insert_buffer_size = 1M #批量插入数据缓存大小，可以有效提高插入效率，默认为8M

       myisam_sort_buffer_size = 1M #MyISAM表发生变化时重新排序所需的缓冲

       myisam_max_sort_file_size = G #MySQL重建索引时所允许的最大临时文件的大小 (当 REPAIR, ALTER TABLE 或者 LOAD DATA INFILE). 如果文件大小比此值更大,索引会通过键值缓冲创建(更慢)

       myisam_repair_threads = 1 #如果一个表拥有超过一个索引, MyISAM 可以通过并行排序使用超过一个线程去修复他们.这对于拥有多个CPU以及大量内存情况的用户,是一个很好的选择.

       myisam_recover #自动检查和修复没有适当关闭的 MyISAM 表

       lower_case_table_names = 1 #让mysql不区分大小写

       skip-name-resolve #禁用DNS解析，连接速度会快很多。不过，这样的话就不能在MySQL的授权表中使用主机名了而只能用ip格式。

       #slave-skip-errors = , #这是选填项让slave库跳过哪些错误继续同步

       #replicate-ignore-db=mysql #选填，同步时候哪个数据库不同步设置

       server-id = 1

       innodb_additional_mem_pool_size = 4M #InnoDB 存储的数据目录信息和其它内部数据结构的内存池大小。应用程序里的表越多，你需要在这里分配越多的内存，默认是2M

       innodb_buffer_pool_size = M #这对Innodb表来说非常重要。Innodb相比MyISAM表对缓冲更为敏感。MyISAM可以在默 认的 key_buffer_size 设置下运行的可以，然而Innodb在默认的 设置下却跟蜗牛似的。由于Innodb把数据和索引都缓存起来，无需留给操作系统太多的内存，因此如果只需要用Innodb的话则可以设置它高达 -% 的可用内存。一些应用于 key_buffer 的规则有 — 如果你的数据量不大，并且不会暴增，那么无需把 innodb_buffer_pool_size 设置的太大了

       innodb_file_io_threads = 4 #文件IO的线程数，一般为 4

       innodb_thread_concurrency = 8 #你的服务器CPU有几个就设置为几,建议用默认一般为8

       innodb_flush_log_at_trx_commit = 2 #默认为1，如果将此参数设置为1，将在每次提交事务后将日志写入磁盘。为提供性能，可以设置为0或2，但要承担在发生故障时丢失数据的风险。设置为0表示事务日志写入日志文件，而日志文件每秒刷新到磁盘一次。设置为2表示事务日志将在提交时写入日志，但日志文件每次刷新到磁盘一次。

       innodb_log_buffer_size = 2M #此参数确定些日志文件所用的内存大小，以M为单位。缓冲区更大能提高性能，但意外的故障将会丢失数据.MySQL开发人员建议设置为1－8M之间

       innodb_log_file_size = 4M #此参数确定数据日志文件的大小，以M为单位，更大的设置可以提高性能，但也会增加恢复故障数据库所需的时间

       innodb_log_files_in_group = 3 #为提高性能，MySQL可以以循环方式将日志文件写到多个文件。推荐设置为3M

       innodb_max_dirty_pages_pct = #Buffer_Pool中Dirty_Page所占的数量，直接影响InnoDB的关闭时间。参数 innodb_max_dirty_pages_pct可以直接控制了Dirty_Page在Buffer_Pool中所占的比率，而且幸运的是 innodb_max_dirty_pages_pct是可以动态改变的。所以，在关闭InnoDB之前先调小，强制数据块Flush一段时间，则能够大大缩短MySQL关闭的时间。

       innodb_lock_wait_timeout = #InnoDB 有其内置的死锁检测机制，能导致未完成的事务回滚。但是，如果结合InnoDB使用MyISAM的lock tables 语句或第三方事务引擎,则InnoDB无法识别死锁。为消除这种可能性，可以将innodb_lock_wait_timeout设置为一个整数值，指示 MySQL在允许其他事务修改那些最终受事务回滚的数据之前要等待多长时间(秒数)

       innodb_file_per_table = 0 #独享表空间（关闭）

       [mysqldump]

       quick

       max_allowed_packet = M

       4. 架构优化

       ï¼ˆ1）. 前端用memcached，redis等缓存分担数据库压力

       ï¼ˆ2）. 数据库读写分离，负载均衡

       ï¼ˆ3）. 数据库分库分表

       ï¼ˆ4）. 存储可采取分布式

       5. 后期优化

       ä¸»è¦æ˜¯å¤šè§‚察，后期就是维护工作了，观察服务器负载是需要添加硬件了，还是有语句有问题啊，还是参数要修改了。

       6. 查询优化（摘抄别人的）

       . 使用慢查询日志去发现慢查询。

       . 使用执行计划去判断查询是否正常运行。

       . 总是去测试你的查询看看是否他们运行在最佳状态下 –久而久之性能总会变化。

       . 避免在整个表上使用count(*),它可能锁住整张表。

       . 使查询保持一致以便后续相似的查询可以使用查询缓存。

       . 在适当的情形下使用GROUP BY而不是DISTINCT。

       . 在WHERE, GROUP BY和ORDER BY子句中使用有索引的列。

       . 保持索引简单,不在多个索引中包含同一个列。

       . 有时候MySQL会使用错误的索引,对于这种情况使用USE INDEX。

       . 检查使用SQL_MODE=STRICT的问题。

       . 对于记录数小于5的索引字段，在UNION的时候使用LIMIT不是是用OR.

       . 为了 避免在更新前SELECT，使用INSERT ON DUPLICATE KEY或者INSERT IGNORE ,不要用UPDATE去实现。

       . 不要使用 MAX,使用索引字段和ORDER BY子句。

       . 避免使用ORDER BY RAND().

       ã€‚LIMIT M，N实际上可以减缓查询在某些情况下，有节制地使用。

       ã€‚在WHERE子句中使用UNION代替子查询。

       ã€‚对于UPDATES（更新），使用 SHARE MODE（共享模式），以防止独占锁。

       ã€‚在重新启动的MySQL，记得来温暖你的数据库，以确保您的数据在内存和查询速度快。

       ã€‚使用DROP TABLE，CREATE TABLE DELETE FROM从表中删除所有数据。

       ã€‚最小化的数据在查询你需要的数据，使用*消耗大量的时间。

       ã€‚考虑持久连接，而不是多个连接，以减少开销。

       ã€‚基准查询，包括使用服务器上的负载，有时一个简单的查询可以影响其他查询。

       ã€‚当负载增加您的服务器上，使用SHOW PROCESSLIST查看慢的和有问题的查询。

       ã€‚在开发环境中产生的镜像数据中 测试的所有可疑的查询。

如何杀掉空闲事务

        本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明网址: /tech/database/how_to_kill_idle_trx.html 我们经常遇到一个情况，就是网络断开或程序Bug导致COMMIT/ROLLBACK语句没有传到数

        本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明网址: /tech/database/how_to_kill_idle_trx.html

       我们经常遇到一个情况，就是网络断开或程序Bug导致COMMIT/ROLLBACK语句没有传到数据库，也没有释放线程，但是线上事务锁定等待严重，连接数暴涨，尤其在测试库这种情况很多，线上也偶有发生，于是想为MySQL增加一个杀掉空闲事务的功能。

       那么如何实现呢，通过MySQL Server层有很多不确定因素，最保险还是在存储引擎层实现，我们用的几乎都是InnoDB/XtraDB，所以就基于Percona来修改了，Oracle版的MySQL也可以照着修改。

       需求：

       1. 一个事务启动，如果事务内最后一个语句执行完超过一个时间(innodb_idle_trx_timeout)，就应该关闭链接。

       2. 如果事务是纯读事务，因为不加锁，所以无害，不需要关闭，保持即可。

       虽然这个思路被Percona的指出Alexey Kopytov可能存在“Even though SELECT queries do not place row locks by default (there are exceptions), they can still block undo log records from being purged.”的问题，但是我们确实有场景SELECT是绝对不能kill的，除非之后的INSERT/UPDATE/DELETE发生了，所以我根据我们的业务特点来修改。

       跟Percona的Yasufumi Kinoshita和Alexey Kopytov提出过纯SELECT事务不应被kill，但通过一个参数控制的方案还没有被Alexey Kopytov接受，作为通用处理我提出了用两个变量分别控制纯读事务的空闲超时时间和有锁事务的空闲超时时间，还在等待Percona的回复，因为这个方案还在测试，就先不开放修改了，当然如果你很熟悉MYSQL源码，我提出这个思路你肯定知道怎么分成这两个参数控制了。

       根据这两个需求我们来设计方法，首先想到这个功能肯定是放在InnoDB Master Thread最方便，Master Thread每秒调度一次，可以顺便检查空闲事务，然后关闭，因为在事务中操作trx->mysql_thd并不安全，所以一般来说最好在InnoDB层换成Thread ID操作，并且InnoDB中除了ha_innodb.cc，其他地方不能饮用THD，所以Master Thread中需要的线程数值，都需要在ha_innodb中计算好传递整型或布尔型返回值给master thread调用。

       首先，我们要增加一个参数：idle_trx_timeout，它表示事务多久没有下一条语句发生就超时关闭。

       在storage/innodb_plugin/srv/srv0srv.c的“/* plugin options */”注释下增加如下代码注册idle_trx_timeout变量。

       static MYSQL_SYSVAR_LONG(idle_trx_timeout, srv_idle_trx_timeout,

        PLUGIN_VAR_RQCMDARG,

        "If zero then this function no effect, if no-zero then wait idle_trx_timeout seconds this transaction will be closed",

        "Seconds of Idle-Transaction timeout",

        NULL, NULL, 0, 0, LONG_MAX, 0);

       代码往下找在innobase_system_variables结构体内加上：

       MYSQL_SYSVAR(idle_trx_timeout),

       有了这个变量，我们需要在Master Thread(storage/innodb_plugin/srv/srv0srv.c )中执行检测函数查找空闲事务。在loop循环的if (sync_array_print_long_waits(&waiter, &sema)判断后加上这段判断

        if (srv_idle_trx_timeout && trx_sys) {

        trx_t* trx;

        time_t now;

       rescan_idle:

        now = time(NULL);

        mutex_enter(&kernel_mutex);

        trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list); # 从当前事务列表里获取第一个事务

        while (trx) { # 依次循环每个事务进行检查

        if (trx->conc_state == TRX_ACTIVE

        && trx->mysql_thd

        && innobase_thd_is_idle(trx->mysql_thd)) { # 如果事务还活着并且它的状态时空闲的

        ib_int_t start_time = innobase_thd_get_start_time(trx->mysql_thd); # 获取线程最后一个语句的开始时间

        ulong thd_id = innobase_thd_get_thread_id(trx->mysql_thd); #获取线程ID，因为存储引擎内直接操作THD不安全

        if (trx->last_stmt_start != start_time) { # 如果事务最后语句起始时间不等于线程最后语句起始时间说明事务是新起的

        trx->idle_start = now; # 更新事务的空闲起始时间

        trx->last_stmt_start = start_time; # 更新事务的最后语句起始时间

        } else if (difftime(now, trx->idle_start) # 如果事务不是新起的，已经执行了一部分则判断空闲时间有多长了

        > srv_idle_trx_timeout) { # 如果空闲时间超过阈值则杀掉链接

        /* kill the session */

        mutex_exit(&kernel_mutex);

        thd_kill(thd_id); # 杀链接

        goto rescan_idle;

        }

        }

        trx = UT_LIST_GET_NEXT(mysql_trx_list, trx); # 检查下一个事务

        }

        mutex_exit(&kernel_mutex);

        }

       其中trx中的变量是新加的，在storage/innodb_plugin/include/trx0trx.h的trx_truct加上需要的变量：

       struct trx_struct{

       ...

        time_t idle_start;

        ib_int_t last_stmt_start;

       ...

       }

       这里有几个函数是自定义的：

       ibool innobase_thd_is_idle(const void* thd);

       ib_int_t innobase_thd_get_start_time(const void* thd);

       ulong innobase_thd_get_thread_id(const void* thd);

       这些函数在ha_innodb.cc中实现，需要在storage/innodb_plugin/srv/srv0srv.c头文件定义下加上这些函数的引用形势。

       然后在storage/innodb_plugin/handler/ha_innodb.cc 中定义这些函数的实现：

       extern "C"

       ibool

       innobase_thd_is_idle(

        const void* thd) /*!{

        return(((const THD*)thd)->command == COM_SLEEP);

       }

       extern "C"

       ib_int_t

       innobase_thd_get_start_time(

        const void* thd) /*!{

        return((ib_int_t)((const THD*)thd)->start_time);

       }

       extern "C"

       ulong

       innobase_thd_get_thread_id(

        const void* thd)

       {

        return(thd_get_thread_id((const THD*) thd));

       }

       还有最重要的thd_kill函数负责杀线程的，在sql/sql_class.cc中，找个地方定义这个函数：

       void thd_kill(ulong id)

       {

        THD *tmp;

        VOID(pthread_mutex_lock(&LOCK_thread_count));

        I_List_iterator it(threads);

        while ((tmp=it++))

        {

        if (tmp->command == COM_DAEMON || tmp->is_have_lock_thd == 0 ) # 如果是DAEMON线程和不含锁的线程就不要kill了

        continue;

        if (tmp->thread_id == id)

        {

        pthread_mutex_lock(&tmp->LOCK_thd_data);

        break;

        }

        }

        VOID(pthread_mutex_unlock(&LOCK_thread_count));

        if (tmp)

        {

        tmp->awake(THD::KILL_CONNECTION);

        pthread_mutex_unlock(&tmp->LOCK_thd_data);

        }

       }

       为了存储引擎能引用到这个函数，我们要把它定义到plugin中：

       include/mysql/plugin.h和include/mysql/plugin.h中加上

       void thd_kill(unsigned long id);

       如何判定线程的is_have_lock_thd值？首先在THD中加上这个变量（sql/sql_class.cc）：

       class THD :public Statement,

        public Open_tables_state

       {

       ....

        uint is_have_lock_thd;

       ....

       }

       然后在SQL的必经之路mysql_execute_command拦上一刀，判断是有锁操作发生了还是事务提交或新起事务。

        switch (lex->sql_command) {

        case SQLCOM_REPLACE:

        case SQLCOM_REPLACE_SELECT:

        case SQLCOM_UPDATE:

        case SQLCOM_UPDATE_MULTI:

        case SQLCOM_DELETE:

        case SQLCOM_DELETE_MULTI:

        case SQLCOM_INSERT:

        case SQLCOM_INSERT_SELECT:

        thd->is_have_lock_thd = 1;

        break;

        case SQLCOM_COMMIT:

        case SQLCOM_ROLLBACK:

        case SQLCOM_XA_START:

        case SQLCOM_XA_END:

        case SQLCOM_XA_PREPARE:

        case SQLCOM_XA_COMMIT:

        case SQLCOM_XA_ROLLBACK:

        case SQLCOM_XA_RECOVER:

        thd->is_have_lock_thd = 0;

        break;

        }

       为了尽可能兼容Percona的补丁，能引用的都引用了Percona的操作，有些函数调用是在层次太多看不下去了就简化了。

       另外还有一个版本是我自己弄的，在THD中增加了一个last_sql_end_time，在do_command结束后更新last_sql_end_time，然后在事务中拿到THD查看last_sql_end_time就可以得出idle时间，Oracle版我还是建议这么做，不要去改trx_struct结构体了，那个感觉更危险。

MySQL 核心模块揭秘 | 期 | 创建 savepoint

       回滚操作，除了回滚整个事务，还可以部分回滚。部分回滚，需要保存点（savepoint）的协助。本文我们先看看保存点里面都有什么。

       作者：操盛春，爱可生技术专家，公众号『一树一溪』作者，专注于研究 MySQL 和 OceanBase 源码。 爱可生开源社区出品，原创内容未经授权不得随意使用，转载请联系小编并注明来源

       本文基于 MySQL 8.0. 源码，存储引擎为 InnoDB。

       InnoDB 的事务对象有一个名为undo_no 的属性。事务每次改变（插入、更新、删除）某个表的一条记录，都会产生一条 undo 日志。这条 undo 日志中会存储它自己的序号。这个序号就来源于事务对象的 undo_no 属性。

       也就是说，事务对象的 undo_no 属性中保存着事务改变（插入、更新、删除）某个表中下一条记录产生的 undo 日志的序号。

       每个事务都维护着各自独立的 undo 日志序号，和其它事务无关。

       每个事务的 undo 日志序号都从 0 开始。事务产生的第 1 条 undo 日志的序号为 0，第 2 条 undo 日志的序号为 1，依此类推。

       InnoDB 的 savepoint 结构中会保存创建 savepoint 时事务对象的 undo_no 属性值。

       我们通过 SQL 语句创建一个 savepoint 时，server 层、binlog、InnoDB 会各自创建用于保存 savepoint 信息的结构。

       server 层的 savepoint 结构是一个SAVEPOINT 类型的对象，主要属性如下：

       binlog 的 savepoint 结构很简单，是一个 8 字节的整数。这个整数的值，是创建 savepoint 时事务已经产生的 binlog 日志的字节数，也是接下来新产生的 binlog 日志写入 trx_cache 的 offset。

       为了方便介绍，我们把这个整数值称为binlog offset。

       InnoDB 的 savepoint 结构是一个trx_named_savept_t 类型的对象，主要属性如下：

       创建 savepoint 时，server 层会分配一块 字节的内存，除了存放它自己的 SAVEPOINT 对象，还会存放 binlog offset 和 InnoDB 的 trx_named_savept_t 对象。

       server 层的 SAVEPOINT 对象占用这块内存的前 字节，InnoDB 的 trx_named_savept_t 对象占用中间的 字节，binlog offset 占用最后的 8 字节。

       客户端连接到 MySQL 之后，MySQL 会分配一个专门用于该连接的用户线程。

       用户线程中有一个m_savepoints 链表，用户创建的多个 savepoint 通过 prev 属性形成链表，m_savepoints 就指向最新创建的 savepoint。

       server 层创建 savepoint 之前，会按照创建时间从新到老，逐个查看链表中是否存在和本次创建的 savepoint 同名的 savepoint。

       如果在用户线程的 m_savepoints 链表中找到了和本次创建的 savepoint 同名的 savepoint，需要先删除 m_savepoints 链表中的同名 savepoint。

       找到的同名 savepoint，是 server 层的SAVEPOINT 对象，它后面的内存区域分别保存着 InnoDB 的 trx_named_savept_t 对象、binlog offset。

       binlog 是个老实孩子，乖乖的把 binlog offset 写入了 server 层为它分配的内存里。删除同名 savepoint 时，不需要单独处理 binlog offset。

       InnoDB 就不老实了，虽然 server 层也为 InnoDB 的 trx_named_savept_t 对象分配了内存，但是 InnoDB 并没有往里面写入内容。

       事务执行过程中，用户每次创建一个 savepoint，InnoDB 都会创建一个对应的 trx_named_savept_t 对象，并加入 InnoDB 事务对象的 trx_savepoints 链表的末尾。

       因为 InnoDB 自己维护了一个存放 savepoint 结构的链表，server 层删除同名 savepoint 时，InnoDB 需要找到这个链表中对应的 savepoint 结构并删除，流程如下：

       InnoDB 从事务对象的 trx_savepoints 链表中删除 trx_named_savept_t 对象之后，server 层接着从用户线程的 m_savepoints 链表中删除 server 层的SAVEPOINT 对象，也就连带着清理了 binlog offset。

       处理完查找、删除同名 savepoint 之后，server 层就正式开始创建 savepoint 了，这个过程分为 3 步。

       第 1 步，binlog 会生成一个 Query_log_event。

       以创建名为test_savept 的 savepoint 为例，这个 event 的内容如下：

       binlog event 写入 trx_cache 之后，binlog offset 会写入 server 层为它分配的 8 字节的内存中。

       第 2 步，InnoDB 创建 trx_named_savept_t 对象，并放入事务对象的 trx_savepoints 链表的末尾。

       trx_named_savept_t 对象的 name 属性值是 InnoDB 的 savepoint 名字。这个名字是根据 server 层为 InnoDB 的 trx_named_savept_t 对象分配的内存的地址计算得到的。

       trx_named_savept_t 对象的savept 属性，是一个 trx_savept_t 类型的对象。这个对象里保存着创建 savepoint 时，事务对象中 undo_no 属性的值，也就是下一条 undo 日志的序号。

       第 3 步，把 server 层的 SAVEPOINT 对象加入用户线程的 m_savepoints 链表的尾部。

       server 层会创建一个SAVEPOINT 对象，用于存放 savepoint 信息。

       binlog 会把binlog offset 写入 server 层为它分配的一块 8 字节的内存里。

       InnoDB 会维护自己的 savepoint 链表，里面保存着trx_named_savept_t 对象。

       如果 m_savepoints 链表中存在和本次创建的 savepoint 同名的 savepoint， 创建新的 savepoint 之前，server 层会从链表中删除这个同名的 savepoint。

       server 层创建的 SAVEPOINT 对象会放入m_savepoints 链表的末尾。

       InnoDB 创建的 trx_named_savept_t 对象会放入事务对象的trx_savepoints 链表的末尾。

tron货币什么情况

       TRON货币目前处于加密货币市场的活跃状态。

       TRON是一种基于区块链技术的开放源代码项目，旨在构建一个全球性的自由内容娱乐系统。其货币TRONIX是该生态系统中的数字代币，主要用于平台上的交易和支付。自推出以来，TRON和TRX都受到了市场的广泛关注，特别是在数字货币领域有着一定的影响力。TRON的工作重点是提供一种可行的方案来构建自由、即时和开放的互联网环境。这个项目的进展也持续引发业界和投资者的兴趣。而具体表现如何，还需结合市场情况进行分析。

       TRON货币的市场表现

       TRON货币的市场表现与全球加密货币市场紧密相关。在全球市场积极的氛围下，TRON货币的价格可能上涨，并受到更多投资者的追捧。随着越来越多的商家和企业开始接受TRX作为支付方式，其实际应用场景也在不断扩大。此外，TRON生态系统中的其他应用和服务也为其货币的普及提供了支持。然而，与其他加密货币一样，TRX的价格也存在波动性，受到市场需求、监管政策和技术发展等多种因素的影响。投资者在参与时应当充分了解和评估风险。

       TRON的技术发展和社区支持

       除了市场表现外，TRON的技术发展和社区支持也是其成功的重要因素。TRON团队一直在努力优化其区块链技术，提高系统的可扩展性和性能。此外，拥有一个活跃的社区也是项目成功的重要推动力。社区成员可以通过各种渠道交流和分享经验，为项目提供宝贵的反馈和建议。这些都有助于推动TRON货币的长远发展。因此总体来看，TRON货币具有发展潜力但也存在风险，投资者需审慎判断。请注意投资有风险，决策需谨慎。