Jak zabić wszystkie procesy w Mysql "Pokaż listę procesów"?

Masowe zabijanie operacja oszczędza czas. Zrób to w samym MySql:

Uruchom te polecenia

mysql> select concat('KILL ',id,';') from information_schema.processlist
where user='root' and time > 200 into outfile '/tmp/a.txt';

mysql> source /tmp/a.txt;

Odniesienie

---------edit------------

Jeśli nie chcesz przechowywać w pliku, przechowuj w variable

Po prostu uruchom w wierszu polecenia

> out1=$(mysql -B test -uroot -proot --disable-column-names  -e "select concat('KILL ',id,';') from information_schema.processlist where user='root' and time > 200;")

> out2= $(mysql -B test -uroot -proot --disable-column-names  -e "$out1")

Przeszukałem również jak parsować przez MySQL polecenie SHOW PROCESSLIST i skończyło się na jednej linijce w powłoce:

mysqladmin processlist -u <USERNAME> -p<PASSWORD> | \
awk '$2 ~ /^[0-9]/ {print "KILL "$2";"}' | \
mysql -u <USERNAME> -p<PASSWORD>

• mysqladmin processlist wyświetli tabelę z identyfikatorami wątków;
• awk przetworzy z drugiej kolumny tylko liczby (ID wątków) i wygeneruje polecenia MySQL KILL;
• i wreszcie ostatnie wywołanie mysql wykona przekazane polecenia.

Możesz uruchomić grep przed awk polecenie filtrowania konkretnej nazwy bazy danych.

Lub... w skorupie...

service mysql restart

Tylko dla mariaDB

To nie staje się prostsze niż to, po prostu wykonaj to w MySQL prompt.

kill USER username;

Zabije wszystkie procesy pod podaną nazwą użytkownika. ponieważ większość ludzi używa tego samego Użytkownika do wszystkich celów, to działa!

Testowałem to na MariaDB nie jestem pewien co do mysql.

Ostatnio musiałem to zrobić i wymyśliłem to

-- GROUP_CONCAT turns all the rows into 1
-- @q:= stores all the kill commands to a variable
select @q:=GROUP_CONCAT(CONCAT('KILL ',ID) SEPARATOR ';')  
FROM information_schema.processlist 
-- If you don't need it, you can remove the WHERE command altogether
WHERE user = 'user';
-- Creates statement and execute it
PREPARE stmt FROM @q;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;

W ten sposób nie musisz przechowywać plików i uruchamiać wszystkich zapytań za pomocą jednego polecenia.

Poniższa procedura utworzy prostą procedurę składowaną, która używa kursora do zabicia wszystkich procesów jeden po drugim, z wyjątkiem obecnie używanego procesu:

DROP PROCEDURE IF EXISTS kill_other_processes;

DELIMITER $$

CREATE PROCEDURE kill_other_processes()
BEGIN
  DECLARE finished INT DEFAULT 0;
  DECLARE proc_id INT;
  DECLARE proc_id_cursor CURSOR FOR SELECT id FROM information_schema.processlist;
  DECLARE CONTINUE HANDLER FOR NOT FOUND SET finished = 1;

  OPEN proc_id_cursor;
  proc_id_cursor_loop: LOOP
    FETCH proc_id_cursor INTO proc_id;

    IF finished = 1 THEN 
      LEAVE proc_id_cursor_loop;
    END IF;

    IF proc_id <> CONNECTION_ID() THEN
      KILL proc_id;
    END IF;

  END LOOP proc_id_cursor_loop;
  CLOSE proc_id_cursor;
END$$

DELIMITER ;

Może być uruchomiony z SELECT s, aby pokazać procesy przed i po w następujący sposób:

SELECT * FROM information_schema.processlist;
CALL kill_other_processes();
SELECT * FROM information_schema.processlist;

KILL ALL SELECT QUERIES

select concat('KILL ',id,';') 
from information_schema.processlist 
where user='root' 
  and INFO like 'SELECT%' into outfile '/tmp/a.txt'; 
source /tmp/a.txt;

Jeśli nie masz information_schema:

mysql -e "show full processlist" | cut -f1 | sed -e 's/^/kill /' | sed -e 's/$/;/' ;  > /tmp/kill.txt
mysql> . /tmp/kill.txt

Ten sniped pracował dla mnie (MySQL server 5.5), aby zabić wszystkie procesy MySQL:

mysql -e "show full processlist;" -ss | awk '{print "KILL "$1";"}'| mysql

Połączyłbym Basha i mysql:

for i in $(mysql -Ne "select id from information_schema.processlist where user like 'foo%user' and time > 300;"); do
  mysql -e "kill ${i}"
done

Zaloguj się do Mysql jako admin:

 mysql -uroot -ppassword;

I polecenie Uruchom:

mysql> show processlist;

Dostaniesz coś takiego jak poniżej:

+----+-------------+--------------------+----------+---------+------+-------+------------------+
| Id | User        | Host               | db       | Command | Time | State | Info             |
+----+-------------+--------------------+----------+---------+------+-------+------------------+
| 49 | application | 192.168.44.1:51718 | XXXXXXXX | Sleep   |  183 |       | NULL             ||
| 55 | application | 192.168.44.1:51769 | XXXXXXXX | Sleep   |  148 |       | NULL             |
| 56 | application | 192.168.44.1:51770 | XXXXXXXX | Sleep   |  148 |       | NULL             |
| 57 | application | 192.168.44.1:51771 | XXXXXXXX | Sleep   |  148 |       | NULL             |
| 58 | application | 192.168.44.1:51968 | XXXXXXXX | Sleep   |   11 |       | NULL             |
| 59 | root        | localhost          | NULL     | Query   |    0 | NULL  | show processlist |
+----+-------------+--------------------+----------+---------+------+-------+------------------+

Zobaczysz pełne szczegóły różnych połączeń. Teraz możesz zabić połączenie spania jak poniżej:

mysql> kill 52;
Query OK, 0 rows affected (0.00 sec)

Oto rozwiązanie, które można wykonać bez polegania na systemie operacyjnym:

Krok 1: Utwórz procedurę składowaną.

DROP PROCEDURE IF EXISTS  kill_user_processes$$ 

CREATE PROCEDURE `kill_user_processes`(
  IN user_to_kill VARCHAR(255)
)
READS SQL DATA
BEGIN

  DECLARE name_val VARCHAR(255);
  DECLARE no_more_rows BOOLEAN;
  DECLARE loop_cntr INT DEFAULT 0;
  DECLARE num_rows INT DEFAULT 0;

  DECLARE friends_cur CURSOR FOR
    SELECT CONCAT('KILL ',id,';') FROM information_schema.processlist WHERE USER=user_to_kill;

  DECLARE CONTINUE HANDLER FOR NOT FOUND
    SET no_more_rows = TRUE;

  OPEN friends_cur;
  SELECT FOUND_ROWS() INTO num_rows;

  the_loop: LOOP

    FETCH  friends_cur
    INTO   name_val;

    IF no_more_rows THEN
        CLOSE friends_cur;
        LEAVE the_loop;
    END IF;


 SET @s = name_val;
    PREPARE stmt FROM @s;
    EXECUTE stmt;
    DEALLOCATE PREPARE stmt;

    SELECT name_val;

    SET loop_cntr = loop_cntr + 1;

  END LOOP the_loop;

  SELECT num_rows, loop_cntr;

END $$
DELIMITER ;

Krok 2: wywołaj procedurę składowaną nadając jej nazwę użytkownika bazy danych, którego procesy chcesz zabić. Możesz przepisać procedurę składowaną, aby filtrować według innych kryteriów, jeśli chcesz.

CALL kill_user_processes('devdba');

mysqladmin pr -u 'USERNAME' -p'PASSWORD' | awk '$2~/^[0-9]+/{print $2}' | xargs -i mysqladmin -u 'USERNAME' -p'PASSWORD' kill {}

Możemy to zrobić przez MySQL Workbench. Po prostu wykonaj to:

kill id;

Przykład:

kill 13412

To go usunie.

W języku python możesz zrobić tak

import pymysql

connection = pymysql.connect(host='localhost',
                             user='root',
                             db='mysql',
                             cursorclass=pymysql.cursors.DictCursor)

with connection.cursor() as cursor:
    cursor.execute('SHOW PROCESSLIST')
    for item in cursor.fetchall():
        if item.get('Time') > 200:
            _id = item.get('Id')
            print('kill %s' % item)
            cursor.execute('kill %s', _id)
    connection.close()

Łatwym sposobem byłoby ponowne uruchomienie serwera mysql.. Otwórz " usługi.msc " w Windows Run wybierz z listy Mysql. Kliknij prawym przyciskiem myszy i zatrzymaj usługę. Następnie uruchom ponownie i wszystkie procesy zostałyby zabite z wyjątkiem jednego (domyślne zarezerwowane Połączenie)

#! /bin/bash
if [ $# != "1" ];then
    echo "Not enough arguments.";
    echo "Usage: killQueryByDB.sh <db_name>";
    exit;
fi;

DB=${1};
for i in `mysql -u <user> -h localhost ${DB} -p<password> -e "show processlist" | sed 's/\(^[0-9]*\).*/\1/'`; do
    echo "Killing query ${i}";
    mysql -u <user> -h localhost ${DB} -p<password> -e "kill query ${i}";
done;

Czasami mam kilka zombie procesów mysql, których nie da się zabić (używając MAMP Pro).

Najpierw pobierz listę wszystkich procesów mysql:

ps -ax | grep mysql

Następnie Zabij każdy z nich za pomocą (zamień processId na pierwszą kolumnę w poprzednim wyniku polecenia):

kill -9 processId

Następujące zadziałały dla mnie świetnie:

echo "show processlist" | mysql | grep -v ^Id | awk '{print $1}' | xargs -i echo "KILL {}; | mysql"

Użyłem polecenia flush tables aby zabić wszystkie nieaktywne połączenia, które w rzeczywistości problem masy.

Jeśli używasz laravel to jest to dla Ciebie:

$query = "SHOW FULL PROCESSLIST";
    $results = DB::select(DB::raw($query));

    foreach($results as $result){
        if($result->Command == "Sleep"){
            $sql="KILL ". $result->Id;
            DB::select(DB::raw($sql));
        }
    }

Oczywiście, powinieneś użyć tego use Illuminate\Support\Facades\DB; po swojej przestrzeni nazw.

ZAPYTANIE 1 wybierz concat('KILL ',id,';') z information_schema.processlist where user = 'username' into outfile '/tmp/a.txt";

Zapytanie 2 źródło a.txt

To pozwoli Ci zabić wszystkie zapytania w show processlist przez konkretnego użytkownika.