it-swarm.com.de

Wie bringe ich alle Prozesse in Mysql "show processlist" ab?

Weil ich dort viele Prozesse sehe, und die Spalte "Zeit" zeigt große Werte für alle.

103
TIMEX

Sie müssen sie einzeln abtöten, MySQL verfügt nicht über einen massiven Befehl zum Töten. Sie können das Skript in jeder Sprache schreiben. In PHP können Sie beispielsweise Folgendes verwenden:

$result = mysql_query("SHOW FULL PROCESSLIST");
while ($row=mysql_fetch_array($result)) {
  $process_id=$row["Id"];
  if ($row["Time"] > 200 ) {
    $sql="KILL $process_id";
    mysql_query($sql);
  }
}
96
Michal Čihař

Mass Tilling - Vorgang spart Zeit. Tun Sie es in MySql selbst:

Führen Sie diese Befehle aus

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;

Referenz

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

wenn Sie nicht in einer Datei speichern möchten, speichern Sie diese in einer variable.

Führen Sie einfach Ihre Eingabeaufforderung aus

> 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")
190
Angelin Nadar

Ich habe auch gesucht, wie man den Befehl SHOW PROCESSLIST durch MySQL durchsucht und mit einem Einzeiler in einer Shell beendet:

mysqladmin processlist -u <USERNAME> -p<PASSWORD> | \
awk '$2 ~ /^[0-9]/ {print "KILL "$2";"}' | \
mysql -u <USERNAME> -p<PASSWORD>
  • mysqladmin processlist druckt eine Tabelle mit den Thread-IDs;
  • awk parst aus der zweiten Spalte nur die Zahlen (Thread-IDs) und generiert MySQL-KILL-Befehle.
  • und schließlich führt der letzte Aufruf von mysql die übergebenen Befehle aus.

Sie können grep vor dem Befehl awk ausführen, um einen bestimmten Datenbanknamen zu filtern.

16
m8t

Oder ... in der Shell ...

service mysql restart

Ja, ich weiß, ich bin faul, aber es kann auch nützlich sein.

12
EcchiOli

Einfacher geht es nicht, führen Sie dies einfach in mysql Prompt aus.

kill USER username;

Der Prozess wird unter dem angegebenen Benutzernamen abgebrochen. Da die meisten Benutzer denselben Benutzer für alle Zwecke verwenden, funktioniert es!

Ich habe dies auf MariaDB getestet, nicht sicher über MySQL.

10
Maulik Gangani

Wenn Sie kein information_schema haben:

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

5
mikesl

Im Folgenden wird eine einfache gespeicherte Prozedur erstellt, die mit einem Cursor alle Prozesse mit Ausnahme des aktuell verwendeten Prozesses nacheinander abbricht:

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 ;

Es kann mit SELECTs ausgeführt werden, um die Prozesse davor und danach wie folgt anzuzeigen:

SELECT * FROM information_schema.processlist;
CALL kill_other_processes();
SELECT * FROM information_schema.processlist;
4
Steve Chambers

melden Sie sich als Admin bei MySQL an:

 mysql -uroot -ppassword;

Und dann den Befehl ausführen:

mysql> show processlist;

Sie erhalten so etwas wie folgt:

+----+-------------+--------------------+----------+---------+------+-------+------------------+
| 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 |
+----+-------------+--------------------+----------+---------+------+-------+------------------+

Sie sehen vollständige Details der verschiedenen Verbindungen. Jetzt können Sie die schlafende Verbindung wie folgt beenden:

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

TÖTE ALLE AUSWÄHLEN 

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

Hier ist eine Lösung, die Sie ausführen können, ohne sich auf das Betriebssystem zu verlassen:

SCHRITT 1: Erstellen Sie eine gespeicherte Prozedur. 

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 ;

SCHRITT 2: Rufen Sie die gespeicherte Prozedur mit dem Namen eines Datenbankbenutzers auf, dessen Prozesse Sie beenden möchten. Sie können die gespeicherte Prozedur umschreiben, um nach anderen Kriterien zu filtern, wenn Sie möchten.

RUFEN kill_user_processes('devdba');

3
Dan Spiegel

Dieser Schnipsel funktionierte für mich (MySQL Server 5.5), um alle MySQL-Prozesse zu beenden: 

mysql -e "show full processlist;" -ss | awk '{print "KILL "$1";"}'| mysql
3
Fedir RYKHTIK
mysqladmin pr -u 'USERNAME' -p'PASSWORD' | awk '$2~/^[0-9]+/{print $2}' | xargs -i mysqladmin -u 'USERNAME' -p'PASSWORD' kill {}
2
user3721740

Wir können das mit MySQL Workbench machen. Führen Sie einfach das aus:

kill id;

Beispiel:

kill 13412

Das wird es entfernen. 

2
Aroon

Ich musste das vor kurzem machen, und ich kam dazu

-- 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;

Auf diese Weise müssen Sie nicht alle Dateien mit einem einzigen Befehl in eine Datei speichern und ausführen.

2
Iberê

Ich würde bash und mysql kombinieren:

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
1
wiebel

Ich habe den Befehl flush tables verwendet, um alle inaktiven Verbindungen zu beenden, bei denen tatsächlich das Massenproblem bestand.

0
Meltzer
#! /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;

Manchmal habe ich einige Zombies-MySQL-Prozesse, die nicht beendet werden können (mit MAMP Pro). 

Holen Sie sich zuerst eine Liste aller mysql-Prozesse:

ps -ax | grep mysql

Als nächstes töten Sie jeden von ihnen mit (ersetzen Sie processId durch die erste Spalte im vorherigen Befehlsergebnis):

kill -9 processId
0
Nico Prat

Wenn Sie Laravel verwenden, ist dies für Sie: 

$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));
        }
    }

Natürlich sollten Sie diesen use Illuminate\Support\Facades\DB; nach Ihrem Namespace verwenden. 

0
Ziaur Rahman

für die Python-Sprache können Sie dies tun

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()
0
BohanZhang

Folgendes hat für mich großartig funktioniert:

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

Ein einfacher Weg wäre, den MySQL-Server neu zu starten .. Öffnen Sie "services.msc" in Windows "Ausführen" und wählen Sie "Mysql" aus der Liste aus. Klicken Sie mit der rechten Maustaste und stoppen Sie den Dienst. Starten Sie dann erneut, und alle Prozesse wären außer demjenigen (der standardmäßig reservierten Verbindung) beendet worden.

0
shashi009