Wie erkennt man, ob ein PHP-Skript bereits läuft?

Question

Ich habe ein Cron-Skript, das alle 10 Minuten ein PHP-Skript ausführt. Das Skript überprüft eine Warteschlange und verarbeitet die Daten in der Warteschlange. Manchmal verfügt die Warteschlange über genügend Daten, um über 10 Minuten der Verarbeitung zu dauern, wodurch das Potenzial von zwei Skripts entsteht, die versuchen, auf dieselben Daten zuzugreifen. Ich möchte feststellen können, ob das Skript bereits ausgeführt wird, um zu verhindern, dass mehrere Kopien des Skripts gestartet werden. Ich dachte darüber nach, ein Datenbank-Flag zu erstellen, das besagt, dass ein Skript verarbeitet wird, aber wenn das Skript jemals abstürzen würde, würde es im positiven Zustand bleiben. Gibt es eine einfache Möglichkeit festzustellen, ob das PHP-Skript bereits mit einem PHP- oder Shell-Skript ausgeführt wird?

Answer 1

Wenn Sie es absolut crashsicher benötigen, sollten Sie semaphores verwenden, die automatisch freigegeben werden, wenn php die spezifische Anforderungsbehandlung beendet.

Ein einfacherer Ansatz wäre, einen DB-Datensatz oder eine Datei zu Beginn der Ausführung zu erstellen und am Ende zu entfernen. Sie können immer das "Alter" dieses Datensatzes/Datei überprüfen, und wenn es älter ist als sagen 3 Mal die normale Skriptausführung, angenommen, dass es abgestürzt ist und es entfernen.

Es gibt keine "Wunderwaffe", es kommt nur auf Ihre Bedürfnisse an.

Answer 2

Ein gängiger Weg für * nix-Daemons (obwohl nicht unbedingt PHP-Skripte, aber es wird funktionieren) ist die Verwendung einer .pid-Datei.

Wenn das Skript startet, prüfen Sie, ob eine .pid-Datei existiert, die nach dem Skript benannt ist (normalerweise in/var/run/gespeichert). Wenn es nicht existiert, erstellen Sie es, indem Sie seinen Inhalt auf die PID des Prozesses setzen, der das Skript ausführt (unter Verwendung von getmypid), und fahren Sie mit der normalen Ausführung fort. Wenn es existiert, lesen Sie die PID aus und sehen Sie, ob dieser Prozess noch läuft, wahrscheinlich indem Sie ps $pid ausführen. Wenn es ausgeführt wird, beenden Sie es. Andernfalls überschreiben Sie den Inhalt mit Ihrer PID (wie oben) und fahren mit der normalen Ausführung fort.

Wenn die Ausführung beendet ist, löschen Sie die Datei.

Answer 3

Ich weiß, das ist eine alte Frage, aber falls jemand anderes hier sucht, werde ich etwas Code posten. Dies habe ich kürzlich in einer ähnlichen Situation gemacht und es funktioniert gut. Setzen Sie diesen Code an den Anfang Ihrer Datei, und wenn das gleiche Skript bereits ausgeführt wird, wird es belassen und das neue beenden.

Ich verwende es, um ein Überwachungssystem zu jeder Zeit laufen zu lassen. Ein Cron-Job startet das Skript alle 5 Minuten, aber wenn der andere nicht aus irgendeinem Grund gestoppt wurde (normalerweise wenn er abgestürzt ist, was sehr selten ist!), Wird der neue sich selbst verlassen.

// The file to store our process file 
define('PROCESS_FILE', 'process.pid'); 

// Check I am running from the command line 
if (PHP_SAPI != 'cli') { 
    log_message('Run me from the command line'); 
    exit; 
} 

// Check if I'm already running and kill myself off if I am 
$pid_running = false; 
if (file_exists(PROCESS_FILE)) { 
    $data = file(PROCESS_FILE); 
    foreach ($data as $pid) { 
     $pid = (int)$pid; 
     if ($pid > 0 && file_exists('/proc/' . $pid)) { 
      $pid_running = $pid; 
      break; 
     } 
    } 
} 
if ($pid_running && $pid_running != getmypid()) { 
    if (file_exists(PROCESS_FILE)) { 
     file_put_contents(PROCESS_FILE, $pid); 
    } 
    log_message('I am already running as pid ' . $pid . ' so stopping now'); 
    exit; 
} else { 
    // Make sure file has just me in it 
    file_put_contents(PROCESS_FILE, getmypid()); 
    log_message('Written pid with id '.getmypid()); 
} 

Es wird nicht ohne Änderung unter Windows funktionieren, sollte aber in Unix-basierten Systemen in Ordnung sein.

Answer 4

Das funktionierte für mich. Legen Sie einen Datenbankdatensatz mit einem Sperrkennzeichen und einem Zeitstempel fest. Mein Skript sollte auch innerhalb 15 Minuten vervollständigen, so dass als letztes Mittel gesperrt Feild zu überprüfen:

 $lockresult = mysql_query(" 
     SELECT * 
     FROM queue_locks 
     WHERE `lastlocked` > DATE_SUB(NOW() , INTERVAL 15 MINUTE)  
     AND `locked` = 'yes' 
     AND `queid` = '1' 
     LIMIT 1 
     "); 
$LockedRowCount = mysql_num_rows($lockresult); 

if($LockedRowCount>0){ 
    echo "this script is locked, try again later"; 
    exit; 
}else{ 
//Set the DB record to locked and carry on son 
$result = mysql_query(" 
      UPDATE `queue_locks` SET `locked` = 'yes', `lastlocked` = CURRENT_TIMESTAMP WHERE `queid` = 1; 
      "); 

} 

Dann entsperren es am Ende des Skripts:

$result = mysql_query("UPDATE `queue_locks` SET `locked` = 'no' WHERE `queid` = 1;"); 

Answer 5

Sie können nur eine Sperrdatei verwenden. PHP flock() Funktion bietet einen einfachen Wrapper für Unix flock Funktion, die beratende Sperren für Dateien bietet.

Wenn Sie sie nicht explizit freigeben, gibt das Betriebssystem diese Sperren automatisch für Sie frei, wenn der Prozess, der sie enthält, beendet wird, auch wenn es abnormal beendet wird.

Sie können auch der lockeren Unix-Konvention folgen, Ihre Sperrdatei zu einer 'PID-Datei' zu machen - das heißt, nachdem Sie eine Sperre für die Datei erhalten haben, lassen Sie Ihr Skript seine PID schreiben. Selbst wenn Sie dies nie in Ihrem Skript lesen, ist es für Sie praktisch, wenn Ihr Skript jemals hängt oder verrückt wird und Sie seine PID finden möchten, um sie manuell zu beenden.

Hier ist ein copy/paste-ready Umsetzung:

#!/usr/bin/php 
<?php 

$lock_file = fopen('path/to/yourlock.pid', 'c'); 
$got_lock = flock($lock_file, LOCK_EX | LOCK_NB, $wouldblock); 
if ($lock_file === false || (!$got_lock && !$wouldblock)) { 
    throw new Exception(
     "Unexpected error opening or locking lock file. Perhaps you " . 
     "don't have permission to write to the lock file or its " . 
     "containing directory?" 
    ); 
} 
else if (!$got_lock && $wouldblock) { 
    exit("Another instance is already running; terminating.\n"); 
} 

// Lock acquired; let's write our PID to the lock file for the convenience 
// of humans who may wish to terminate the script. 
ftruncate($lock_file, 0); 
fwrite($lock_file, getmypid() . "\n"); 

/* 
    The main body of your script goes here. 
*/ 
echo "Hello, world!"; 

// All done; we blank the PID file and explicitly release the lock 
// (although this should be unnecessary) before terminating. 
ftruncate($lock_file, 0); 
flock($lock_file, LOCK_UN); 

einfach den Pfad der Sperrdatei auf, wo immer Sie möchten und Sie werden eingestellt.

Answer 6

können Sie neue verwenden Symfony 2.6 LockHandler

$lock = new LockHandler('update:contents'); 
if (!$lock->lock()) { 
    echo 'The command is already running in another process.'; 
} 

Answer 7

Ich weiß, dass dies eine alte Frage, aber es ist ein Ansatz, der vor, dass ich glaube nicht erwähnt worden ist, eine Überlegung wert ist.

Eines der Probleme mit einer Lockfile oder Datenbank Flag Lösung, wie bereits erwähnt, ist, dass wenn das Skript aus einem anderen Grund als normale Beendigung fehlschlägt die Sperre nicht freigegeben wird. Daher wird die nächste Instanz nicht gestartet, bis die Sperre entweder manuell gelöscht oder durch eine Bereinigungsfunktion gelöscht wurde.

Wenn Sie jedoch sicher sind, dass das Skript nur einmal ausgeführt werden soll, ist es relativ einfach, innerhalb des Skripts zu überprüfen, ob es beim Starten bereits ausgeführt wird. Hier einige Code:

function checkrun() { 
    exec("ps auxww",$ps); 
    $r = 0; 
    foreach ($ps as $p) { 
     if (strpos($p,basename(__FILE__))) { 
      $r++; 
      if ($r > 1) { 
       echo "too many instances, exiting\n"; 
       exit(); 
      } 
     } 
    } 
} 

Rufen Sie einfach diese Funktion zu Beginn des Skripts, bevor Sie irgendetwas anderes tun (wie zB offene Datenbank-Handler oder eine Importdatei verarbeiten), und wenn das gleiche Skript bereits läuft dann Es erscheint zweimal in der Prozessliste - einmal für die vorherige Instanz und einmal für diese. Also, wenn es mehr als einmal erscheint, einfach verlassen.

Ein potenzieller Fehler hier: Ich gehe davon aus, dass Sie nie zwei Skripte mit dem gleichen Basisnamen haben werden, die möglicherweise gleichzeitig laufen (zB das gleiche Skript läuft unter zwei verschiedenen Benutzern). Wenn dies möglich ist, müssen Sie die Überprüfung auf etwas komplizierteres erweitern als eine einfache Teilzeichenfolge für den Basisnamen der Datei. Aber das funktioniert gut genug, wenn Sie eindeutige Dateinamen für Ihre Skripte haben.

Answer 8

Wenn Sie Linux läuft, sollte dies am Anfang des Skripts arbeiten:

$running = exec("ps aux|grep ". basename(__FILE__) ."|grep -v grep|wc -l"); 
if($running > 1) { 
    exit; 
} 

Answer 9

Fügen Sie einfach folgende am Anfang des Skripts.

<?php 
    // Ensures single instance of script run at a time. 
    $fileName = basename(__FILE__); 
    $output = shell_exec("ps -ef | grep -v grep | grep $fileName | wc -l"); 
    //echo $output; 
    if ($output > 2) 
    { 
     echo "Already running - $fileName\n"; 
     exit; 
    } 

    // Your php script code. 
?> 

Answer 10

Ich habe dies versucht. Funktioniert auch in Windows gut.

$status_file=__DIR__.'/mail_process.txt'; 
    if(file_exists($status_file) && file_get_contents($status_file)=='running'){ 
       echo 'Program running'; 
      exit; 
    } 
    file_put_contents($status_file,'running'); 

     // Code block 
     //........... 

    file_put_contents($status_file,'finished'); 

Danke an @martinodf für seine Idee.