Mysql佔用CPU過高如何優化,如何解決
Mysql佔用CPU過高如何優化
一次生產DB伺服器的 超負荷執行問題解決:
1.檢視生產DB伺服器top列表,
執行 top 命令
檢視Cpu(s) 引數一直處於 98% 狀態 ,load average達到了 5 (4核伺服器)
可見DB已經超負荷運行了
2.使用root使用者登入mysql
執行 show full processlist 檢視慢查詢,反覆執行,發現一直有3個select 查詢語句存在,為了緩解DB伺服器壓力,直接使用kill命令殺掉
kill 慢查詢的id
伺服器壓力緩解,恢復正常。
使用這條SQL語句去專案中找到對應功能,經查是沒用的功能,直接隱藏這個功能,問題解決。
Mysql佔用CPU過高如何優化?
MySQL處在高負載環境下,磁碟IO讀寫過多,肯定會佔用很多資源,必然CP會U佔用過高。佔用CPU過高,可以做如下考慮:
1.開啟慢查詢日誌,查詢是否是某個SQL語句佔用過多資源,如果是的話,可以對SQL語句進行優化,比如優化 insert 語句、優化 group by 語句、優化 order by 語句、優化 join 語句等等;
2.考慮索引問題;
3.定期分析表,使用optimize table;
4.優化資料庫物件;
5.考慮是否是鎖問題;
6.調整一些MySQL Server引數,比如key_buffer_size、table_cache、innodb_buffer_pool_size、innodb_log_file_size等等;
7.如果資料量過大,可以考慮使用MySQL叢集或者搭建高可用環境。
mysql show processlist + show status + kill Id命令詳解
1. SHOW PROCESSLIST
顯示哪些執行緒正在執行。您也可以使用mysqladmin processlist語句得到此資訊。如果您有SUPER許可權,您可以看到所有執行緒。否則,您只能看到您自己的執行緒(也就是,與您正在使用的MySQL 賬戶相關的執行緒)。請參見13.5.5.3節,“KILL語法”。如果您不使用FULL關鍵詞,則只顯示每個查詢的前100個字元。
本語句報告TCP/IP連線的主機名稱(採用host_name:client_port格式),以方便地判定哪個客戶端正在做什麼。
如果您得到“too many connections”錯誤資訊,並且想要了解正在發生的情況,本語句是非常有用的。MySQL保留一個額外的連線,讓擁有SUPER許可權的 賬戶使用,以確保管理員能夠隨時連線和檢查系統(假設您沒有把此許可權給予所有的使用者)。
這個命令中最關鍵的就是state列,mysql列出的狀態主要有以下幾種:
Checking table
正在檢查資料表(這是自動的)。
Closing tables
正在將表中修改的資料重新整理到磁碟中,同時正在關閉已經用完的表。這是一個很快的操作,如果不是這樣的話,就應該確認磁碟空間是否已經滿了或者磁碟是否正處於重負中。
Connect Out
複製從伺服器正在連線主伺服器。
Copying to tmp table on disk
由於臨時結果集大於tmp_table_size,正在將臨時表從記憶體儲存轉為磁碟儲存以此節省記憶體。
Creating tmp table
正在建立臨時表以存放部分查詢結果。
deleting from main table
伺服器正在執行多表刪除中的第一部分,剛刪除第一個表。
deleting from reference tables
伺服器正在執行多表刪除中的第二部分,正在刪除其他表的記錄。
Flushing tables
正在執行FLUSH TABLES,等待其他執行緒關閉資料表。
Killed
傳送了一個kill請求給某執行緒,那麼這個執行緒將會檢查kill標誌位,同時會放棄下一個kill請求。MySQL會在每次的主迴圈中檢查 kill標誌位,不過有些情況下該執行緒可能會過一小段才能死掉。如果該執行緒程被其他執行緒鎖住了,那麼kill請求會在鎖釋放時馬上生效。
Locked
被其他查詢鎖住了。
Sending data
正在處理SELECT查詢的記錄,同時正在把結果傳送給客戶端。
Sorting for group
正在為GROUP BY做排序。
Sorting for order
正在為ORDER BY做排序。
Opening tables
這個過程應該會很快,除非受到其他因素的干擾。例如,在執ALTER TABLE或LOCK TABLE語句行完以前,資料表無法被其他執行緒開啟。正嘗試開啟一個表。
Removing duplicates
正在執行一個SELECT DISTINCT方式的查詢,但是MySQL無法在前一個階段優化掉那些重複的記錄。因此,MySQL需要再次去掉重複的記錄,然後再把結果傳送給客戶端。
Reopen table
獲得了對一個表的鎖,但是必須在表結構修改之後才能獲得這個鎖。已經釋放鎖,關閉資料表,正嘗試重新開啟資料表。
Repair by sorting
修復指令正在排序以建立索引。
Repair with keycache
修復指令正在利用索引快取一個一個地建立新索引。它會比Repair by sorting慢些。
Searching rows for update
正在講符合條件的記錄找出來以備更新。它必須在UPDATE要修改相關的記錄之前就完成了。
Sleeping
正在等待客戶端傳送新請求.
System lock
正在等待取得一個外部的系統鎖。如果當前沒有執行多個mysqld伺服器同時請求同一個表,那麼可以通過增加--skip-external-locking引數來禁止外部系統鎖。
Upgrading lock
INSERT DELAYED正在嘗試取得一個鎖表以插入新記錄。
Updating
正在搜尋匹配的記錄,並且修改它們。
User Lock
正在等待GET_LOCK()。
Waiting for tables
該執行緒得到通知,資料表結構已經被修改了,需要重新開啟資料表以取得新的結構。然後,為了能的重新開啟資料表,必須等到所有其他執行緒關閉這個 表。以下幾種情況下會產生這個通知:FLUSH TABLES tbl_name, ALTER TABLE, RENAME TABLE, REPAIR TABLE, ANALYZE TABLE,或OPTIMIZE TABLE。
waiting for handler insert
INSERT DELAYED已經處理完了所有待處理的插入操作,正在等待新的請求。
大部分狀態對應很快的操作,只要有一個執行緒保持同一個狀態好幾秒鐘,那麼可能是有問題發生了,需要檢查一下。
還有其他的狀態沒在上面中列出來,不過它們大部分只是在檢視伺服器是否有存在錯誤是才用得著。
mysql 檢視當前連線數
命令: show processlist;
如果是root帳號,你能看到所有使用者的當前連線。如果是其它普通帳號,只能看到自己佔用的連線。
show processlist;只列出前100條,如果想全列出請使用show full processlist;
mysql> show processlist;
2. show status
Aborted_clients 由於客戶沒有正確關閉連線已經死掉,已經放棄的連線數量。
Aborted_connects 嘗試已經失敗的MySQL伺服器的連線的次數。
Connections 試圖連線MySQL伺服器的次數。
Created_tmp_tables 當執行語句時,已經被創造了的隱含臨時表的數量。
Delayed_insert_threads 正在使用的延遲插入處理器執行緒的數量。
Delayed_writes 用INSERT DELAYED寫入的行數。
Delayed_errors 用INSERT DELAYED寫入的發生某些錯誤(可能重複鍵值)的行數。
Flush_commands 執行FLUSH命令的次數。
Handler_delete 請求從一張表中刪除行的次數。
Handler_read_first 請求讀入表中第一行的次數。
Handler_read_key 請求數字基於鍵讀行。
Handler_read_next 請求讀入基於一個鍵的一行的次數。
Handler_read_rnd 請求讀入基於一個固定位置的一行的次數。
Handler_update 請求更新表中一行的次數。
Handler_write 請求向表中插入一行的次數。
Key_blocks_used 用於關鍵字快取的塊的數量。
Key_read_requests 請求從快取讀入一個鍵值的次數。
Key_reads 從磁碟物理讀入一個鍵值的次數。
Key_write_requests 請求將一個關鍵字塊寫入快取次數。
Key_writes 將一個鍵值塊物理寫入磁碟的次數。
Max_used_connections 同時使用的連線的最大數目。
Not_flushed_key_blocks 在鍵快取中已經改變但是還沒被清空到磁碟上的鍵塊。
Not_flushed_delayed_rows 在INSERT DELAY佇列中等待寫入的行的數量。
Open_tables 開啟表的數量。
Open_files 開啟檔案的數量。
Open_streams 開啟流的數量(主要用於日誌記載)
Opened_tables 已經開啟的表的數量。
Questions 發往伺服器的查詢的數量。
Slow_queries 要花超過long_query_time時間的查詢數量。
Threads_connected 當前開啟的連線的數量。
Threads_running 不在睡眠的執行緒數量。
Uptime 伺服器工作了多少秒。
After create
This occurs when the thread creates a table (including internal temporary tables), at the end of the function that creates the table. This state is used even if the table could not be created due to some error.
Analyzing
The thread is calculating a MyISAM table key distributions (for example, for ANALYZE TABLE).
checking permissions
The thread is checking whether the server has the required privileges to execute the statement.
Checking table
The thread is performing a table check operation.
cleaning up
The thread has processed one command and is preparing to free memory and reset certain state variables.
closing tables
The thread is flushing the changed table data to disk and closing the used tables. This should be a fast operation. If not, you should verify that you do not have a full disk and that the disk is not in very heavy use.
converting HEAP to MyISAM
The thread is converting an internal temporary table from a MEMORY table to an on-disk MyISAM table.
copy to tmp table
The thread is processing an ALTER TABLE statement. This state occurs after the table with the new structure has been created but before rows are copied into it.
Copying to group table
If a statement has different ORDER BY and GROUP BY criteria, the rows are sorted by group and copied to a temporary table.
Copying to tmp table
The server is copying to a temporary table in memory.
Copying to tmp table on disk
The server is copying to a temporary table on disk. The temporary result set was larger than tmp_table_size and the thread is changing the temporary table from in-memory to disk-based format to save memory.
Creating index
The thread is processing ALTER TABLE ... ENABLE KEYS for a MyISAM table.
Creating sort index
The thread is processing a SELECT that is resolved using an internal temporary table.
creating table
The thread is creating a table. This includes creation of temporary tables.
Creating tmp table
The thread is creating a temporary table in memory or on disk. If the table is created in memory but later is converted to an on-disk table, the state during that operation will be Copying to tmp table on disk.
deleting from main table
The server is executing the first part of a multiple-table delete. It is deleting only from the first table, and saving columns and offsets to be used for deleting from the other (reference) tables.
deleting from reference tables
The server is executing the second part of a multiple-table delete and deleting the matched rows from the other tables.
discard_or_import_tablespace
The thread is processing an ALTER TABLE ... DISCARD TABLESPACE or ALTER TABLE ... IMPORT TABLESPACE statement.
end
This occurs at the end but before the cleanup of ALTER TABLE, CREATE VIEW, DELETE, INSERT, SELECT, or UPDATE statements.
executing
The thread has begun executing a statement.
Execution of init_command
The thread is executing statements in the value of the init_command system variable.
freeing items
The thread has executed a command. This state is usually followed by cleaning up.
Flushing tables
The thread is executing FLUSH TABLES and is waiting for all threads to close their tables.
FULLTEXT initialization
The server is preparing to perform a natural-language full-text search.
init
This occurs before the initialization of ALTER TABLE, DELETE, INSERT, SELECT, or UPDATE statements.
Killed
Someone has sent a KILL statement to the thread and it should abort next time it checks the kill flag. The flag is checked in each major loop in MySQL, but in some cases it might still take a short time for the thread to die. If the thread is
locked by some other thread, the kill takes effect as soon as the other thread releases its lock.
Locked
The query is locked by another query.
logging slow query
The thread is writing a statement to the slow-query log.
NULL
This state is used for the SHOW PROCESSLIST state.
login
The initial state for a connection thread until the client has been authenticated successfully.
Opening tables, Opening table
The thread is trying to open a table. This is should be very fast procedure, unless something prevents opening. For example, an ALTER TABLE or a LOCK TABLE statement can prevent opening a table until the statement is finished.
preparing
This state occurs during query optimization.
Purging old relay logs
The thread is removing unneeded relay log files.
query end
This state occurs after processing a query but before the freeing items state.
Reading from net
The server is reading a packet from the network.
Removing duplicates
The query was using SELECT DISTINCT in such a way that MySQL could not optimize away the distinct operation at an early stage. Because of this, MySQL requires an extra stage to remove all duplicated rows before sending the result to the client.
removing tmp table
The thread is removing an internal temporary table after processing a SELECT statement. This state is not used if no temporary table was created.
rename
The thread is renaming a table.
rename result table
The thread is processing an ALTER TABLE statement, has created the new table, and is renaming it to replace the original table.
Reopen tables
The thread got a lock for the table, but noticed after getting the lock that the underlying table structure changed. It has freed the lock, closed the table, and is trying to reopen it.
Repair by sorting
The repair code is using a sort to create indexes.
Repair done
The thread has completed a multi-threaded repair for a MyISAM table.
Repair with keycache
The repair code is using creating keys one by one through the key cache. This is much slower than Repair by sorting.
Rolling back
The thread is rolling back a transaction.
Saving state
For MyISAM table operations such as repair or analysis, the thread is saving the new table state to the .MYI file header. State includes information such as number of rows, the AUTO_INCREMENT counter, and key distributions.
Searching rows for update
The thread is doing a first phase to find all matching rows before updating them. This has to be done if the UPDATE is changing the index that is used to find the involved rows.
Sending data
The thread is processing rows for a SELECT statement and also is sending data to the client.
setup
The thread is beginning an ALTER TABLE operation.
Sorting for group
The thread is doing a sort to satisfy a GROUP BY.
Sorting for order
The thread is doing a sort to satisfy a ORDER BY.
Sorting index
The thread is sorting index pages for more efficient access during a MyISAM table optimization operation.
Sorting result
For a SELECT statement, this is similar to Creating sort index, but for nontemporary tables.
statistics
The server is calculating statistics to develop a query execution plan.
System lock
The thread is going to request or is waiting for an internal or external system lock for the table. If this state is being caused by requests for external locks and you are not using multiple mysqld servers that are accessing the same tables,
you can disable external system locks with the --skip-external-locking option. However, external locking is disabled by default, so it is likely that this option will have no effect. For SHOW PROFILE, this state means the thread is requesting the lock (not
waiting for it).
Table lock
The next thread state after System lock. The thread has acquired an external lock and is going to request an internal table lock.
Updating
The thread is searching for rows to update and is updating them.
updating main table
The server is executing the first part of a multiple-table update. It is updating only the first table, and saving columns and offsets to be used for updating the other (reference) tables.
updating reference tables
The server is executing the second part of a multiple-table update and updating the matched rows from the other tables.
User lock
The thread is going to request or is waiting for an advisory lock requested with a GET_LOCK() call. For SHOW PROFILE, this state means the thread is requesting the lock (not waiting for it).
Waiting for tables, Waiting for table
The thread got a notification that the underlying structure for a table has changed and it needs to reopen the table to get the new structure. However, to reopen the table, it must wait until all other threads have closed the table in question.
This notification takes place if another thread has used FLUSH TABLES or one of the following statements on the table in question: FLUSH TABLES tbl_name, ALTER TABLE, RENAME TABLE, REPAIR TABLE, ANALYZE TABLE, or OPTIMIZE TABLE.
Waiting on cond
A generic state in which the thread is waiting for a condition to become true. No specific state information is available.
Writing to net
The server is writing a packet to the network.
3. kill mysql 執行執行緒
(1) show processlist;
-----------+
| 152 | root | 192.168.0.100:1808 | atomic_data | Query | 5600 | copy to tmp table | alter table `atomic_data`.`basic_point_beijing_p1`
change `valid` `type` int(2) NULL ,
chang |
| 155 | root | 192.168.0.100:1944 | atomic_data | Query | 4702 | Locked | alter table `atomic_data`.`basic_point_beijing_p1`
change `valid` `type` int(2) NULL ,
chang |
| 158 | root | localhost | atomic_data | Query | 0 | NULL | show processlist |
(2) kill 152;
Query OK, 0 rows affected (0.00 sec)
(3) show preocesslist;
+-----+------+--------------------+-------------+---------+------+-------------------+------------------------------------------------------------------------------------------------------+
| Id | User | Host |
db |
Command | Time | State |
Info |
+-----+------+--------------------+-------------+---------+------+-------------------+------------------------------------------------------------------------------------------------------+
| 155 | root | 192.168.0.100:1944 | atomic_data | Query | 4840 | copy to tmp table | alter table `atomic_data`.`basic_point_beijing_p1`
change `valid` `type` int(2) NULL ,
chang |
| 158 | root | localhost |
atomic_data | Query | 0 | NULL |
show processlist
以下內容來自mysql手冊:
13.5.5.3. KILL語法
KILL [CONNECTION | QUERY] thread_id
每個與mysqld的連線都在一個獨立的執行緒裡執行,您可以使用SHOW PROCESSLIST語句檢視哪些執行緒正在執行,並使用KILL thread_id語句終止一個執行緒。
KILL允許自選的CONNECTION或QUERY修改符:
· KILL CONNECTION與不含修改符的KILL一樣:它會終止與給定的thread_id有關的連線。
· KILL QUERY會終止連線當前正在執行的語句,但是會保持連線的原狀。
如果您擁有PROCESS許可權,則您可以檢視所有執行緒。如果您擁有SUPER許可權,您可以終止所有執行緒和語句。否則,您只能檢視和終止您自己的執行緒和語句。
您也可以使用mysqladmin processlist和mysqladmin kill命令來檢查和終止執行緒。
註釋:您不能同時使用KILL和Embedded MySQL Server庫,因為內植的伺服器只執行主機應用程式的執行緒。它不能建立任何自身的連線執行緒。
當您進行一個KILL時,對執行緒設定一個特有的終止標記。在多數情況下,執行緒終止可能要花一些時間,這是因為終止標記只會在在特定的間隔被檢查:
· 在SELECT, ORDER BY和GROUP BY迴圈中,在讀取一組行後檢查標記。如果設定了終止標記,則該語句被放棄。
· 在ALTER TABLE過程中,在每組行從原來的表中被讀取前,檢查終止標記。如果設定了終止標記,則語句被放棄,臨時表被刪除。
· 在UPDATE或DELETE執行期間,在每個組讀取之後以及每個已更行或已刪除的行之後,檢查終止標記。如果終止標記被設定,則該語句被放棄。注意,如果您正在使用事務,則變更不會被 回滾。
· GET_LOCK()會放棄和返回NULL。
· INSERT DELAYED執行緒會快速地重新整理(插入)它在儲存器中的所有的行,然後終止。
· 如果執行緒在表鎖定管理程式中(狀態:鎖定),則表鎖定被快速地放棄。
· 如果在寫入呼叫中,執行緒正在等待空閒的磁碟空間,則寫入被放棄,並伴隨"disk full"錯誤訊息。
· 警告:對MyISAM表終止一個REPAIR TABLE或OPTIMIZE TABLE操作會導致出現一個被損壞的沒有用的表。對這樣的表的任何讀取或寫入都會失敗,直到您再次優化或修復它(不中斷)。
1、通過information_schema.processlist表中的連線資訊生成需要處理掉的MySQL連線的語句臨時檔案,然後執行臨時檔案中生成的指令
mysql> select concat('KILL ',id,';') from information_schema.processlist where user='root'; +------------------------+ | concat('KILL ',id,';') +------------------------+ | KILL 3101; | KILL 2946; +------------------------+ 2 rows in set (0.00 sec) mysql>select concat('KILL ',id,';') from information_schema.processlist where user='root' into outfile '/tmp/a.txt'; Query OK, 2 rows affected (0.00 sec) mysql>source /tmp/a.txt; Query OK, 0 rows affected (0.00 sec)
2、
殺掉當前所有的MySQL連線
mysqladmin -uroot -p processlist|awk -F "|" '{print $2}'|xargs -n 1 mysqladmin -uroot -p kill
殺掉指定使用者執行的連線,這裡為Mike
mysqladmin -uroot -p processlist|awk -F "|" '{if($3 == "Mike")print $2}'|xargs -n 1 mysqladmin -uroot -p kill
3、通過SHEL指令碼實現
#殺掉鎖定的MySQL連線 for id in `mysqladmin processlist|grep -i locked|awk '{print $1}'` do mysqladmin kill ${id} done
4、通過Maatkit工具集中提供的mk-kill命令進行
#殺掉超過60秒的sql mk-kill -busy-time 60 -kill #如果你想先不殺,先看看有哪些sql執行超過60秒 mk-kill -busy-time 60 -print #如果你想殺掉,同時輸出殺掉了哪些程序 mk-kill -busy-time 60 -print –kill
mk-kill更多用法可參考:
http://www.maatkit.org/doc/mk-kill.html
http://www.sbear.cn/archives/426
Maatkit工具集的其它用法可參考:
http://code.google.com/p/maatkit/wiki/TableOfContents?tm=6
參考文件:
http://www.google.com
http://www.orczhou.com/index.php/2010/10/kill-mysql-connectio-in-batch/
http://www.mysqlperformanceblog.com/2009/05/21/mass-killing-of-mysql-connections/