mysql出現主從同步延遲有哪些原因

1.從庫太多導致復制延遲

創(chuàng)新互聯公司主營陽江網站建設的網絡公司,主營網站建設方案,app軟件定制開發(fā),陽江h(huán)5成都微信小程序搭建,陽江網站營銷推廣歡迎陽江等地區(qū)企業(yè)咨詢

優(yōu)化：建議從庫數量3-5個為宜

2.從庫硬件比主庫硬件差

優(yōu)化：提升硬件性能

3.慢SQL語句過多

優(yōu)化：SQL語句執(zhí)行時間太長，需要優(yōu)化SQL語句

4.主從復制的設計問題

優(yōu)化：主從復制單線程，可以通過多線程IO方案解決；另外MySQL5.6.3支持多線程IO復制。

5.主從庫之間的網絡延遲

優(yōu)化：盡量鏈路短，提升端口帶寬

6.主庫讀寫壓力大

優(yōu)化：前端加buffer和緩存。主從延遲不同步：

不管有多延遲，只要不影響業(yè)務就沒事

7、業(yè)務設計缺陷導致延遲影響業(yè)務

優(yōu)化：從庫沒有數據改讀主庫

mysql數據庫如何優(yōu)化？誰能給出點具體的解決方案？

1、explain：解釋sql的執(zhí)行計劃，后邊的sql不執(zhí)行

2、explain partitions ：用于查看存在分區(qū)的表的執(zhí)行計劃

3、explain extended：待驗證

4、show warnings:

5、show create table:查看表的詳細的創(chuàng)建語句，便于用戶對表進行優(yōu)化

6、show indexes :產看表的所有索引，show indexes from table_name，同樣也可以從information_schema.statistics表中獲得同樣的信息。cardinality列很重要，表示數據量。

7、show tables status: 查看數據庫表的底層大小以及表結構，同樣可以從information_schema.tables表中獲得底層表的信息。

8、show [global|session]status:可以查看mysql服務器當前內部狀態(tài)信息。可以幫助卻行mysql服務器的負載的各種指標。默認是session。同information_schema.global_status和information_schema.session_status

9、show [global|session] variables ：查看當前mysql系統變量的值，其中一些值能影響到sql語句的執(zhí)行方式。同information_schema.global_variables和information_schema.session_variables;

10、information_schema:包含的表的數量和mysql的版本有關系。

mysql優(yōu)化

1，sql的編譯順序

sql 編譯順序 from… on… join… where… order by… group by… having… select…

2，查看sql語句性能:

explain 查詢sql語句

3，優(yōu)化

(1). 最佳作前綴，使用索引順序(按編譯順序)與定義索引時順序一致，若該字段有跳過、反序，該字段及后面字段索引失效

(2). where條件中一切不是=的操作大概率會使索引失效，包括in、!=、、is null、計算、函數等等

(3). 查詢字段與條件字段不一致時使用子查詢，避免臨時表出現

(4). 若用了復合索引，盡量使用全部索引字段

(5). 能不查詢多字段時，盡量使用索引覆蓋

(6). 使用like模糊查詢時，按關鍵字左匹配，即‘x%’，若使用’%x%’，索引失效

(7). or會使全部索引失效

(8). 盡量不要導致類型轉換，否則索引失效

(9). 使用order by時，根據表中數據量調整單路還是雙路查詢，也可以調整buffer區(qū)大?。喝鐂et_max_length_for_sort_data = 1024 (單位byte)

(10). 避免使用select *…

(11). 分頁偏移量大時，盡量使用子查詢 select * from tab where id=(select id from tab limit 100000,1) limit 100;

mysql優(yōu)化：覆蓋索引（延遲關聯）

我們都知道InnoDB采用的B+ tree來實現索引的，索引又分為主鍵索引(聚簇索引)和普通索引(二級索引)。

那么我們就來看下 基于主鍵索引和普通索引的查詢有什么區(qū)別？

舉個栗子：

可以看出我們有一個普通索引k，那么兩顆B+樹的示意圖如下：

[圖片上傳失敗...(image-9b05f7-1597911217600)]

（注：圖來自極客時間專欄）

當我們查詢** select * from T where k=5 其實會先到k那個索引樹上查詢k = 5，然后找到對應的id為500，最后回表到主鍵索引的索引樹找返回所需數據。

如果我們查詢 select id from T where k=5 **則不需要回表就直接返回。

也就是說，基于非主鍵索引的查詢需要多掃描一棵索引樹。因此，我們在應用中應該盡量使用主鍵查詢。

概念如上，這里我們還是用例子來說明：

/pre

[圖片上傳失敗...(image-20977-1597911217600)]

（注：圖來自極客時間專欄）

現在，我們一起來看看這條SQL查詢語句的執(zhí)行流程： select * from T where k between 3 and 5

在這個過程中， 回到主鍵索引樹搜索的過程，我們稱為回表。 可以看到，這個查詢過程讀了k索引樹的3條記錄（步驟1、3和5），回表了兩次（步驟2和4）。

在這個例子中，由于查詢結果所需要的數據只在主鍵索引上有，所以不得不回表。那么，有沒有可能經過索引優(yōu)化，避免回表過程呢？

如果執(zhí)行的語句是select ID from T where k between 3 and 5，這時只需要查ID的值，而ID的值已經在k索引樹上了，因此可以直接提供查詢結果，不需要回表。也就是說，在這個查詢里面，索引k已經“覆蓋了”我們的查詢需求，我們稱為覆蓋索引。

由于覆蓋索引可以減少樹的搜索次數，顯著提升查詢性能，所以使用覆蓋索引是一個常用的性能優(yōu)化手段。

需要注意的是，在引擎內部使用覆蓋索引在索引k上其實讀了三個記錄，R3~R5（對應的索引k上的記錄項），但是對于MySQL的Server層來說，它就是找引擎拿到了兩條記錄，因此MySQL認為掃描行數是2。

上面介紹了那么多 其實是在為延遲關聯做鋪墊，這里直接續(xù)上我們本次慢查詢的sql：

我們都知道在做分頁時會用到Limit關鍵字去篩選所需數據，limit接受1個或者2個參數，接受兩個參數時第一個參數表示偏移量，即從哪一行開始取數據，第二個參數表示要取的行數。 如果只有一個參數，相當于偏移量為0。

當偏移量很大時，如limit 100000,10 取第100001-100010條記錄，mysql會取出100010條記錄然后將前100000條記錄丟棄，這無疑是一種巨大的性能浪費。

當有這種寫法時，我們可以采用延遲關聯來進行優(yōu)化，重點關注： SELECT id FROM qa_question WHERE expert_id = 69 AND STATUS = 30 ORDER BY over_time DESC LIMIT 0, 10 ， 這里其實利用了索引覆蓋，where條件后的expert_id 是有添加索引的，這里查詢id 可以避免回表，大大提升效率。

工作中會遇到各種各樣的問題，對于一個研發(fā)來說最重要的是能夠從這些問題中學到什么。好久沒有寫博客了，究其原因還是自己變得懶惰了。 (￣ェ￣;)

最后以《高性能Mysql》中的一段話結束：

mysql如何優(yōu)化以下語句，查詢耗時太久了？

一般進行性能分析，分如下三步：

首先需要使用慢查詢日志功能，去獲取所有查詢時間比較長的SQL語句

其次查看執(zhí)行計劃查看有問題的SQL的執(zhí)行計劃 explain

最后可以使用show profile查看有問題的SQL的性能使用情況

慢查詢日志分析

首先我們要使用慢查詢日志，因為它收集了查詢時間比較長的SQL語句，但使用之前必須開啟慢查詢日志，在配置文件my.cnf（一般為/etc/my.cnf）中的[mysqld] 增加如下參數：

slow_query_log=ONlong_query_time=3slow_query_log_file=/var/lib/mysql/slow-log.log復制代碼

增加這些參數之后，重啟MySQL，可以進行查詢慢查詢日志是否開啟。

1. 任何地方都不要使用 select * from t，用具體的字段列表代替“*“，不要返回用不到的任何字段。

2. 索引并不是越多越好，索引固然可以提高相應的 select 的效率，但同時也降低了 insert 及 update 的效率，因為 insert 或 update 時有可能會重建索引，所以怎樣建索引需要慎重考慮，視具體情況而定。一個表的索引數最好不要超過6個，若太多則應考慮一些不常使用到的列上建的索引是否有必要。

3. 并不是所有索引對查詢都有效，SQL是根據表中數據來進行查詢優(yōu)化的，當索引列有大量數據重復時，SQL查詢可能不會去利用索引，如一表中有字段sex，male、female幾乎各一半，那么即使在sex上建了索引也對查詢效率起不了作用。

4. 盡量使用數字型字段，若只含數值信息的字段盡量不要設計為字符型，這會降低查詢和連接的性能，并會增加存儲開銷。這是因為引擎在處理查詢和連接時會逐個比較字符串中每一個字符，而對于數字型而言只需要比較一次就夠了。

5. 盡可能的使用 varchar 代替 char ，因為首先變長字段存儲空間小，可以節(jié)省存儲空間， 其次對于查詢來說，在一個相對較小的字段內搜索效率顯然要高些。

6. 如果使用到了臨時表，在存儲過程的最后務必將所有的臨時表顯式刪除，先 truncate table ，然后 drop table ，這樣可以避免系統表的較長時間鎖定。

7. 對查詢進行優(yōu)化，應盡量避免全表掃描，首先應考慮在 where和order by相關的列上建立索引。

8. 應盡量避免在 where 子句中對字段進行 null 值判斷，否則將導致引擎放棄使用索引而進行全表掃描。

例如： select * from t where num is null

我們可以在num上設置默認值0，確保表中num列沒有null值，然后這樣查詢：select * from t where num=0。

mysql服務器讀取速度優(yōu)化

在開始演示之前，我們先介紹下兩個概念。

概念一，數據的可選擇性基數，也就是常說的cardinality值。

查詢優(yōu)化器在生成各種執(zhí)行計劃之前，得先從統計信息中取得相關數據，這樣才能估算每步操作所涉及到的記錄數，而這個相關數據就是cardinality。簡單來說，就是每個值在每個字段中的唯一值分布狀態(tài)。

比如表t1有100行記錄，其中一列為f1。f1中唯一值的個數可以是100個，也可以是1個，當然也可以是1到100之間的任何一個數字。這里唯一值越的多少，就是這個列的可選擇基數。

那看到這里我們就明白了，為什么要在基數高的字段上建立索引，而基數低的的字段建立索引反而沒有全表掃描來的快。當然這個只是一方面，至于更深入的探討就不在我這篇探討的范圍了。

概念二，關于HINT的使用。

這里我來說下HINT是什么，在什么時候用。

HINT簡單來說就是在某些特定的場景下人工協助MySQL優(yōu)化器的工作，使她生成最優(yōu)的執(zhí)行計劃。一般來說，優(yōu)化器的執(zhí)行計劃都是最優(yōu)化的，不過在某些特定場景下，執(zhí)行計劃可能不是最優(yōu)化。

比如：表t1經過大量的頻繁更新操作，（UPDATE,DELETE,INSERT），cardinality已經很不準確了，這時候剛好執(zhí)行了一條SQL，那么有可能這條SQL的執(zhí)行計劃就不是最優(yōu)的。為什么說有可能呢？

來看下具體演示

譬如，以下兩條SQL，

A：

select * from t1 where f1 = 20;

B：

select * from t1 where f1 = 30;

如果f1的值剛好頻繁更新的值為30，并且沒有達到MySQL自動更新cardinality值的臨界值或者說用戶設置了手動更新又或者用戶減少了sample page等等，那么對這兩條語句來說，可能不準確的就是B了。

這里順帶說下，MySQL提供了自動更新和手動更新表cardinality值的方法，因篇幅有限，需要的可以查閱手冊。

那回到正題上，MySQL 8.0 帶來了幾個HINT，我今天就舉個index_merge的例子。

示例表結構：

mysql desc t1;+------------+--------------+------+-----+---------+----------------+| Field ? ? ?| Type ? ? ? ? | Null | Key | Default | Extra ? ? ? ? ?|+------------+--------------+------+-----+---------+----------------+| id ? ? ? ? | int(11) ? ? ?| NO ? | PRI | NULL ? ?| auto_increment || rank1 ? ? ?| int(11) ? ? ?| YES ?| MUL | NULL ? ?| ? ? ? ? ? ? ? ?|| rank2 ? ? ?| int(11) ? ? ?| YES ?| MUL | NULL ? ?| ? ? ? ? ? ? ? ?|| log_time ? | datetime ? ? | YES ?| MUL | NULL ? ?| ? ? ? ? ? ? ? ?|| prefix_uid | varchar(100) | YES ?| ? ? | NULL ? ?| ? ? ? ? ? ? ? ?|| desc1 ? ? ?| text ? ? ? ? | YES ?| ? ? | NULL ? ?| ? ? ? ? ? ? ? ?|| rank3 ? ? ?| int(11) ? ? ?| YES ?| MUL | NULL ? ?| ? ? ? ? ? ? ? ?|+------------+--------------+------+-----+---------+----------------+7 rows in set (0.00 sec)

表記錄數：

mysql select count(*) from t1;+----------+| count(*) |+----------+| ? ?32768 |+----------+1 row in set (0.01 sec)

這里我們兩條經典的SQL：

SQL C：

select * from t1 where rank1 = 1 or rank2 = 2 or rank3 = 2;

SQL D：

select * from t1 where rank1 =100 ?and rank2 =100 ?and rank3 =100;

表t1實際上在rank1,rank2,rank3三列上分別有一個二級索引。

那我們來看SQL C的查詢計劃。

顯然，沒有用到任何索引，掃描的行數為32034，cost為3243.65。

mysql explain ?format=json select * from t1 ?where rank1 =1 or rank2 = 2 or rank3 = 2\G*************************** 1. row ***************************EXPLAIN: { ?"query_block": { ? ?"select_id": 1, ? ?"cost_info": { ? ? ?"query_cost": "3243.65" ? ?}, ? ?"table": { ? ? ?"table_name": "t1", ? ? ?"access_type": "ALL", ? ? ?"possible_keys": [ ? ? ? ?"idx_rank1", ? ? ? ?"idx_rank2", ? ? ? ?"idx_rank3" ? ? ?], ? ? ?"rows_examined_per_scan": 32034, ? ? ?"rows_produced_per_join": 115, ? ? ?"filtered": "0.36", ? ? ?"cost_info": { ? ? ? ?"read_cost": "3232.07", ? ? ? ?"eval_cost": "11.58", ? ? ? ?"prefix_cost": "3243.65", ? ? ? ?"data_read_per_join": "49K" ? ? ?}, ? ? ?"used_columns": [ ? ? ? ?"id", ? ? ? ?"rank1", ? ? ? ?"rank2", ? ? ? ?"log_time", ? ? ? ?"prefix_uid", ? ? ? ?"desc1", ? ? ? ?"rank3" ? ? ?], ? ? ?"attached_condition": "((`ytt`.`t1`.`rank1` = 1) or (`ytt`.`t1`.`rank2` = 2) or (`ytt`.`t1`.`rank3` = 2))" ? ?} ?}}1 row in set, 1 warning (0.00 sec)

我們加上hint給相同的查詢，再次看看查詢計劃。

這個時候用到了index_merge,union了三個列。掃描的行數為1103，cost為441.09，明顯比之前的快了好幾倍。

mysql explain ?format=json select /*+ index_merge(t1) */ * from t1 ?where rank1 =1 or rank2 = 2 or rank3 = 2\G*************************** 1. row ***************************EXPLAIN: { ?"query_block": { ? ?"select_id": 1, ? ?"cost_info": { ? ? ?"query_cost": "441.09" ? ?}, ? ?"table": { ? ? ?"table_name": "t1", ? ? ?"access_type": "index_merge", ? ? ?"possible_keys": [ ? ? ? ?"idx_rank1", ? ? ? ?"idx_rank2", ? ? ? ?"idx_rank3" ? ? ?], ? ? ?"key": "union(idx_rank1,idx_rank2,idx_rank3)", ? ? ?"key_length": "5,5,5", ? ? ?"rows_examined_per_scan": 1103, ? ? ?"rows_produced_per_join": 1103, ? ? ?"filtered": "100.00", ? ? ?"cost_info": { ? ? ? ?"read_cost": "330.79", ? ? ? ?"eval_cost": "110.30", ? ? ? ?"prefix_cost": "441.09", ? ? ? ?"data_read_per_join": "473K" ? ? ?}, ? ? ?"used_columns": [ ? ? ? ?"id", ? ? ? ?"rank1", ? ? ? ?"rank2", ? ? ? ?"log_time", ? ? ? ?"prefix_uid", ? ? ? ?"desc1", ? ? ? ?"rank3" ? ? ?], ? ? ?"attached_condition": "((`ytt`.`t1`.`rank1` = 1) or (`ytt`.`t1`.`rank2` = 2) or (`ytt`.`t1`.`rank3` = 2))" ? ?} ?}}1 row in set, 1 warning (0.00 sec)

我們再看下SQL D的計劃：

不加HINT，

mysql explain format=json select * from t1 where rank1 =100 and rank2 =100 and rank3 =100\G*************************** 1. row ***************************EXPLAIN: { ?"query_block": { ? ?"select_id": 1, ? ?"cost_info": { ? ? ?"query_cost": "534.34" ? ?}, ? ?"table": { ? ? ?"table_name": "t1", ? ? ?"access_type": "ref", ? ? ?"possible_keys": [ ? ? ? ?"idx_rank1", ? ? ? ?"idx_rank2", ? ? ? ?"idx_rank3" ? ? ?], ? ? ?"key": "idx_rank1", ? ? ?"used_key_parts": [ ? ? ? ?"rank1" ? ? ?], ? ? ?"key_length": "5", ? ? ?"ref": [ ? ? ? ?"const" ? ? ?], ? ? ?"rows_examined_per_scan": 555, ? ? ?"rows_produced_per_join": 0, ? ? ?"filtered": "0.07", ? ? ?"cost_info": { ? ? ? ?"read_cost": "478.84", ? ? ? ?"eval_cost": "0.04", ? ? ? ?"prefix_cost": "534.34", ? ? ? ?"data_read_per_join": "176" ? ? ?}, ? ? ?"used_columns": [ ? ? ? ?"id", ? ? ? ?"rank1", ? ? ? ?"rank2", ? ? ? ?"log_time", ? ? ? ?"prefix_uid", ? ? ? ?"desc1", ? ? ? ?"rank3" ? ? ?], ? ? ?"attached_condition": "((`ytt`.`t1`.`rank3` = 100) and (`ytt`.`t1`.`rank2` = 100))" ? ?} ?}}1 row in set, 1 warning (0.00 sec)

加了HINT，

mysql explain format=json select /*+ index_merge(t1)*/ * from t1 where rank1 =100 and rank2 =100 and rank3 =100\G*************************** 1. row ***************************EXPLAIN: { ?"query_block": { ? ?"select_id": 1, ? ?"cost_info": { ? ? ?"query_cost": "5.23" ? ?}, ? ?"table": { ? ? ?"table_name": "t1", ? ? ?"access_type": "index_merge", ? ? ?"possible_keys": [ ? ? ? ?"idx_rank1", ? ? ? ?"idx_rank2", ? ? ? ?"idx_rank3" ? ? ?], ? ? ?"key": "intersect(idx_rank1,idx_rank2,idx_rank3)", ? ? ?"key_length": "5,5,5", ? ? ?"rows_examined_per_scan": 1, ? ? ?"rows_produced_per_join": 1, ? ? ?"filtered": "100.00", ? ? ?"cost_info": { ? ? ? ?"read_cost": "5.13", ? ? ? ?"eval_cost": "0.10", ? ? ? ?"prefix_cost": "5.23", ? ? ? ?"data_read_per_join": "440" ? ? ?}, ? ? ?"used_columns": [ ? ? ? ?"id", ? ? ? ?"rank1", ? ? ? ?"rank2", ? ? ? ?"log_time", ? ? ? ?"prefix_uid", ? ? ? ?"desc1", ? ? ? ?"rank3" ? ? ?], ? ? ?"attached_condition": "((`ytt`.`t1`.`rank3` = 100) and (`ytt`.`t1`.`rank2` = 100) and (`ytt`.`t1`.`rank1` = 100))" ? ?} ?}}1 row in set, 1 warning (0.00 sec)

對比下以上兩個，加了HINT的比不加HINT的cost小了100倍。

總結下，就是說表的cardinality值影響這張的查詢計劃，如果這個值沒有正常更新的話，就需要手工加HINT了。相信MySQL未來的版本會帶來更多的HINT。