Schreiben Sie ein Programm, das sich nach Beendigung von selbst neu startet.

Es sollte nicht mehr als eine Instanz des Programms gleichzeitig ausgeführt werden. Nicht einmal für den geringsten Moment.

Sie können jede Instanz ignorieren, die vom Benutzer während Ihres Zyklus manuell gestartet wurde. Ihr Code sollte dies jedoch in Ihrem Neustartzyklus nicht tun.

Das Programm kann nach einer beliebigen Zeit gestartet werden, sofern sichergestellt ist, dass es erneut gestartet wird.

Der Zyklus kann nur gestoppt werden, indem der Prozess abgebrochen wird.

Ihre Lösung sollte keinen Neustart der Umgebung beinhalten (in der das Programm ausgeführt wird, einschließlich Betriebssystem, Computer, VM, Shell usw.). Nur Ihr Programm darf neu starten.

Bash-Schrift, 3 Zeichen (Kürzeste, möglicherweise eleganteste, wenn auch zugegebenermaßen kontroverse)

$0&

Platziert einfach eine neue Instanz von sich selbst im Hintergrund (neuer Prozess) und wird dann beendet. Die neue Instanz verbleibt wahrscheinlich in der Ausführungswarteschlange des Schedulers, bis die vorherige Instanz ausgeführt wurde.

Warnung - Dies ist schwierig kill, da sich die PID ständig ändert. Das vorübergehende Umbenennen der Skriptdatei ist wahrscheinlich die einfachste Möglichkeit, den Zyklus zu unterbrechen.

Ein Single-Core-System wird angenommen. Natürlich ist dies mit Linux auf moderner Bare-Metal-Hardware nicht realistisch, aber es ist leicht konfigurierbar, wenn es in einer VM ausgeführt wird. Wir könnten wahrscheinlich einen ähnlichen Trick mit erzielen taskset, aber das würde die Auswirkung der 3-Zeichen-Lösung verringern.

Diese Antwort verbiegt die Regeln ein wenig, indem sie eine bestimmte Bedeutung von "Laufen" anwendet. Es wird Momente geben, in denen der neue Prozess fork()bearbeitet wurde und der alte Prozess noch aktiv ist - dh es kann möglich sein, mehr als eine PID zu beobachten. Der neue Prozess wird jedoch in die Ausführungswarteschlange des Linux-Schedulers gestellt, um auf CPU-Zyklen zu warten, während der vorhandene Prozess weiterhin ausgeführt wird. An diesem Punkt muss alles, was der bestehende Prozess tun muss, für bashsich sein exit(). Dies nimmt eine endliche Zeit in Anspruch, obwohl ich ziemlich zuversichtlich bin, dass dies lange vor dem aktuellen Zeitscheiben- / Scheduler-Quantum geschehen wird. Unterstützende Beweise sind die Tatsache, dass bashauf meiner VM in 2 ms gestartet und heruntergefahren wird:

$ time bash -c:

echte 0m0.002s
Benutzer 0m0.000s
sys 0m0.000s
$ 

Weitere Belege dafür, dass der neue Prozess erst dann ausgeführt wird, wenn der vorherige Prozess abgeschlossen ist, sind in der straceAusgabe zu sehen :

strace -f -tt -o forever.strace bash -c ./forever.sh 

In der Ausgabe sehen wir, dass der ursprüngliche Prozess die PID 6929 hat. Wir können den fork()Aufruf (tatsächlich clone()) sehen, der eine neue PID von 6930 zurückgibt. Zu diesem Zeitpunkt gibt es 2 PIDs, aber derzeit läuft nur 6929:

6929 12: 11: 01.031398 clone (child_stack = 0, flags = CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | SIGCHLD, child_tidptr = 0x7f2f83ac49d0) = 6930
6929 12: 11: 01.031484 rt_sigprocmask (SIG_SETMASK, [], NULL, 8) = 0
6929 12: 11: 01.031531 rt_sigprocmask (SIG_BLOCK, [CHLD], [], 8) = 0
6929 12: 11: 01.031577 rt_sigprocmask (SIG_BLOCK, [CHLD], [CHLD], 8) = 0
6929 12: 11: 01.031608 rt_sigprocmask (SIG_SETMASK, [CHLD], NULL, 8) = 0
6929 12: 11: 01.031636 rt_sigprocmask (SIG_BLOCK, [CHLD], [CHLD], 8) = 0
6929 12: 11: 01.031665 rt_sigprocmask (SIG_SETMASK, [CHLD], NULL, 8) = 0
6929 12: 11: 01.031692 rt_sigprocmask (SIG_BLOCK, [CHLD], [CHLD], 8) = 0
6929 12: 11: 01.031726 rt_sigprocmask (SIG_SETMASK, [CHLD], NULL, 8) = 0
6929 12: 11: 01.031757 rt_sigprocmask (SIG_SETMASK, [], NULL, 8) = 0
6929 12: 11: 01.031803 rt_sigprocmask (SIG_BLOCK, NULL, [], 8) = 0
6929 12: 11: 01.031841 read (255, "", 4) = 0
6929 12: 11: 01.031907 exit_group (0) =?
6930 12: 11: 01.032016 close (255) = 0
6930 12: 11: 01.032052 rt_sigprocmask (SIG_SETMASK, [], NULL, 8) = 0

Volle straceAusgabe hier.

Wir können sehen, dass 6930 keine Systemaufrufe ausgibt, bis 6929 vollständig abgeschlossen ist. Es ist anzunehmen, dass 6930 erst nach Abschluss von 6929 ausgeführt wird. Das perfDienstprogramm wäre der ultimative Weg, um dies zu beweisen.

Lösung 1

PHP, 32 Zeichen

Es sendet den Header und stoppt dann. Nach 3 Sekunden wird die Seite neu geladen.

Datei a.php

header("Refresh: 3; url=a.php");

Dies kann durch Beenden der Ausführung der Seite vor dem Senden der Header oder einfach durch Beenden des Browsers gestoppt werden.

Lösung 2

PHP, 2 Seiten

Betrachten wir die beiden Dateien als zwei verschiedene Programme. Die beiden Dateien befinden sich im selben Ordner.

Datei a.php

header("Location:b.php");

Datei b.php

header("Location:a.php");

Wenn Sie eine der Seiten beenden, bevor die Header gesendet werden, wird das Programm beendet (auch das Beenden des Browsers funktioniert).

Hier ist das gleiche Programm in

ASP.NET

Datei a.aspx

Response.Redirect("b.aspx")

Datei b.aspx

Response.Redirect("a.aspx")

Sch

echo $PWD/$0 | at tomorrow

Dies funktioniert auf jedem Posix-kompatiblen System.

Um es zu töten, löschen Sie die Datei oder verwenden Sie atrm.

Bash

exec "$0"

execErsetzt die Shell, ohne einen neuen Prozess zu erstellen. Dies stellt sicher, dass es keine zweite Instanz geben kann.

Windows Task Scheduler (Native)

C ++. Ein Albtraum der COM-Programmierung. Erfüllt alle Herausforderungsanforderungen.

#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <taskschd.h>
#include <comutil.h>

#pragma comment(lib, "taskschd.lib")
#pragma comment(lib, "comsuppw.lib")    

static void timeplus (int seconds, char timestr[30]);


int main () {

    CoInitializeEx(NULL, COINIT_MULTITHREADED);
    CoInitializeSecurity(NULL, -1, NULL, NULL,
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
        RPC_C_IMP_LEVEL_IMPERSONATE, NULL, 0, NULL);

    const char *name = "Restarter";

    char path[MAX_PATH + 1];
    GetModuleFileNameA(NULL, path, sizeof(path));
    path[sizeof(path) - 1] = 0; // workaround for xp

    ITaskService *taskman;
    CoCreateInstance(CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER,
        IID_ITaskService, (void **)&taskman);

    taskman->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());

    ITaskFolder *root;
    taskman->GetFolder(_bstr_t("\\"), &root);

    // Delete the task.
    root->DeleteTask(_bstr_t(name), 0);

    // pause for 5 seconds to give user a chance to kill the cycle
    fprintf(stderr, "If you want to kill the program, close this window now.\n");
    Sleep(5000);
    fprintf(stderr, "Sorry, time's up, maybe next time.\n");

    // Create the task for 5 seconds from now.
    ITaskDefinition *task;
    taskman->NewTask(0, &task);

    IPrincipal *principal;
    task->get_Principal(&principal);
    principal->put_LogonType(TASK_LOGON_INTERACTIVE_TOKEN);

    ITaskSettings *settings;
    task->get_Settings(&settings);
    settings->put_StartWhenAvailable(VARIANT_TRUE);
    settings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);
    settings->put_StopIfGoingOnBatteries(VARIANT_FALSE);

    ITriggerCollection *triggers;
    task->get_Triggers(&triggers);

    ITrigger *trigger;
    triggers->Create(TASK_TRIGGER_TIME, &trigger);

    char when[30];
    ITimeTrigger *trigger_time;
    trigger->QueryInterface(IID_ITimeTrigger, (void **)&trigger_time);
    trigger_time->put_Id(_bstr_t("TimeTrigger"));
    timeplus(10, when);
    trigger_time->put_StartBoundary(_bstr_t(when));
    timeplus(300, when);
    trigger_time->put_EndBoundary(_bstr_t(when));

    IActionCollection *actions;
    task->get_Actions(&actions);

    IAction *action;
    actions->Create(TASK_ACTION_EXEC, &action);

    IExecAction *action_exec;
    action->QueryInterface(IID_IExecAction, (void **)&action_exec);
    action_exec->put_Path(_bstr_t(path));

    IRegisteredTask *regtask;
    root->RegisterTaskDefinition(_bstr_t(name), task,
        TASK_CREATE_OR_UPDATE, _variant_t(), _variant_t(),
        TASK_LOGON_INTERACTIVE_TOKEN, _variant_t(""),
        &regtask);

    regtask->Release();
    action_exec->Release();
    actions->Release();
    trigger_time->Release();
    trigger->Release();
    triggers->Release();
    settings->Release();
    principal->Release();
    task->Release();
    root->Release();
    taskman->Release();
    CoUninitialize();

}


// outputs current utc time + given number of seconds as 
// a string of the form YYYY-MM-DDTHH:MM:SSZ
static void timeplus (int seconds, char timestr[30]) {

    SYSTEMTIME when;
    FILETIME whenf;
    LARGE_INTEGER tempval;

    GetSystemTimeAsFileTime(&whenf);
    tempval.HighPart = whenf.dwHighDateTime;
    tempval.LowPart = whenf.dwLowDateTime;
    tempval.QuadPart += seconds * 10000000LL; // 100 nanosecond units
    whenf.dwHighDateTime = tempval.HighPart;
    whenf.dwLowDateTime = tempval.LowPart;
    FileTimeToSystemTime(&whenf, &when);

    sprintf(timestr, "%04hu-%02hu-%02huT%02hu:%02hu:%02huZ",
        when.wYear, when.wMonth, when.wDay,
        when.wHour, when.wMinute, when.wSecond);

}

Kompilieren Sie mit MSVC (oder MinGW GCC, wenn Sie alle Abhängigkeiten haben).

Das Programm startet und registriert eine einmalige Aufgabe beim Windows-Taskplaner, um sich 5 Sekunden später selbst zu starten (Systemsteuerung -> Verwaltung -> Taskplaner, um anzuzeigen, die Aufgabe heißt "Neustarter"). Das Programm wird 5 Sekunden lang angehalten, damit Sie es beenden können, bevor die Aufgabe erstellt wird.

Herausforderungsanforderungen:

• Startet sich selbst wieder, wenn Sie fertig sind. Ja. Die Aufgabe ist unmittelbar vor dem Beenden des Programms geplant.

• Es kann nicht mehr als eine Instanz des Programms gleichzeitig ausgeführt werden. Ja. Das Programm wird vollständig beendet und 5 Sekunden lang nicht ausgeführt. Es wird vom Scheduler gestartet.

• Sie können jede Instanz ignorieren, die vom Benutzer während Ihres Zyklus manuell gestartet wurde. Ja, als Nebeneffekt der Verwendung eines konstanten Aufgabennamens.

• Solange garantiert ist, dass es wieder losgeht. Ja, vorausgesetzt, der Taskplaner wird ausgeführt (in einer Standard-Windows-Konfiguration).

• Der Zyklus kann nur gestoppt werden, indem der Prozess abgebrochen wird. Ja, der Vorgang kann während des 5-Sekunden-Fensters abgebrochen werden, während er ausgeführt wird. Das Programm löscht die Aufgabe vor der Verzögerung von 5 Sekunden. Wenn Sie sie zu diesem Zeitpunkt beenden, verbleibt keine Streuaufgabe im Scheduler.

• Ihre Lösung sollte keinen Neustart der Umgebung beinhalten. Ja.

Übrigens, wenn sich jemals jemand gefragt hat, warum Windows-Anwendungen (vor dem Aufkommen von .NET und C #) so instabil waren, ist dies einer der Gründe. Der Umfang der erforderlichen Fehlerbehandlung (sofern ich sie berücksichtigt habe), des Ressourcenmanagements und der Ausführlichkeit führt zu sehr fehleranfälligen Situationen, wenn ein Programmierer auch nur ein bisschen faul ist (der obige Code ist extrem faul).

Eine viel einfachere und kürzere Alternative ist das Aufrufen von schtasks.exe. Ich habe damit auch eine Version in einem .BAT-Skript eingereicht .

BBC BASIC - eine Hommage an Snow Patrol

Emulator bei bbcbasic.co.uk

Das ist ein bisschen anders. Es druckt einen Vers des Songs "Run" und spielt ein Arpeggio der Akkorde, so dass Sie mitsingen können. Es war inspiriert von der Tatsache, dass der auszuführende Befehl (und damit die letzte Zeile des Programms) natürlich RUN ist.

Alle Variablen werden beim Start des Programms gelöscht, sodass anhand der Bildschirmfarbe der vorherigen Iteration entschieden wird, welcher Vers als nächstes gedruckt werden soll.

    5 C=POINT(0,0) MOD 4
   10 COLOUR 129+C
   15 CLS
   20 RESTORE 110+C
   25 READ A$
   30 PRINT A$
   35 FORK = 1 TO 4
   40   RESTORE K+100
   45   READ P
   50   FORM= 1 TO 8
   55     SOUND 1,-15,P,7
   60     SOUND 1,-15,P-20,7
   65   NEXT
   70 NEXT
  101 DATA 100
  102 DATA 128
  103 DATA 136
  104 DATA 120
  110 DATA Light up light up - As if you have a choice - Even if you can not hear my voice - I'll be right beside you dear.
  111 DATA Louder louder - And we'll run for our lives - I can hardly speak - I understand - Why you can't raise your voice to say.
  112 DATA Slower Slower - We dont have time for that - All I want is to find an easier way - To get out of our little heads.
  113 DATA Have heart my dear - We're bound to be afraid - Even if its just for a few days - Makin' up for all of this mess.
  120 RUN

OUTPUT (Montage von 4 verschiedenen Screenshots)

HTML / JavaScript:

<form /><script>document.forms[0].submit()</script>

Der Code löst die Zerstörung der Seite aus, auf der er ausgeführt wird, und die Neuerstellung einer weiteren Instanz von sich selbst, wenn der Browser die Seite erneut lädt.

AFAIK, der einzige Ausweg besteht darin, den Tab abzubrechen, auf dem die Seite ausgeführt wird.

BEARBEITEN: laut populärer Anfrage ein gültiger HTML5 Code:

<!doctype html><meta charset=utf-8><title> </title><form></form>
<script>document.forms[0].submit()</script>

C

Dieses Programm wirkt wie viel Malware. Kurz bevor es geschlossen wird, erstellt es ein Shell-Skript im Verzeichnis / tmp. Sie werden aufgefordert, das Shell-Skript zu starten, mit dem das ursprüngliche Programm geschlossen und die ursprüngliche PID abgebrochen werden kann. Nach kurzer Zeit (2 Sekunden) startet das Shell-Skript einen neuen Prozess mit dem Programm. Der Kürze halber ist der Programmspeicherort mit '/ tmp / neverend /' fest verdrahtet.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>

void rebirth(){
    char t[] = "/tmp/pawnXXXXXX";
    char* pawnfile = mktemp(t);
    if(pawnfile){
        int fd = open(pawnfile, O_RDWR|O_CREAT);
        const char msg[]="sleep 2\n/tmp/neverend\n";
        if(fd>0){
            int n = write(fd, msg, sizeof(msg));
            close(fd);
            pid_t pid = fork();
            if(pid==0){
                char* args[3] = {"bash", pawnfile, NULL};
                execvp(args[0], args);
            }
        }
    }
}

int main(int argc, char* argv[]){
    printf("Starting %s\n", argv[0]);
    atexit(rebirth);
    printf("Exiting %s\n", argv[0]);
}

Es wird immer nur ein "nie endender" Prozess gleichzeitig ausgeführt. Jeder neue Prozess erhält eine neue PID. Der einfachste Weg, dies zu beenden, ist das Löschen der ausführbaren Datei. Wenn Sie es bösartiger machen möchten, können Sie sowohl die ausführbare Datei als auch das Skript kopieren, um sicherzustellen, dass sich jederzeit mehrere Kopien auf der Festplatte des Programms befinden.

Perl

`perl -e"kill 9,$$"|perl $0`

Das Skript gibt einen Systembefehl aus, um sich selbst zu beenden und das Ergebnis in eine andere Instanz von sich selbst zu leiten. Der Perl-Interpreter wird aus plattformübergreifenden Gründen zum Töten verwendet.

Stoppen Sie den Wahnsinn, indem Sie das Skript löschen.

Atari 8-Bit Basic

1L.:R.

Tokens für:

1 LIST : RUN

Intern löscht es die internen Strukturen, löscht im Wesentlichen das Programm, bevor es erneut aus der Auflistung ausgeführt wird.

Dies unterscheidet sich grundlegend von:

1L.:G.1

Welches symbolisiert zu:

1 LIST : GOTO 1

Dies ist eine grundlegende Endlosschleife. Wenn Sie sie ausführen, sehen Sie den Unterschied in der Geschwindigkeit (zuerst ist langsamer).

Auf einem IBM Mainframe unter z / OS führen Sie ein Dienstprogramm aus, das eine Datenmenge (Datei) in eine andere Datenmenge (Datei) kopiert. Die Eingabe ist die Quelle der JCL (Job Control Language), die Sie zur Ausführung übergeben haben. Der Ausgang ist der interne Leser (INTRDR). Sie müssen auch sicherstellen, dass Ihr System die Ausführung mehrerer identischer Jobnamen nicht zulässt. Es ist gut, eine Jobklasse zu verwenden, die nur einen Initiator hat (Ort, an dem ein Job im Batch ausgeführt werden kann).

Es sind keine PIDs beteiligt (in z / OS), daher schlägt der Abfragesatz fehl.

Sie stoppen den Prozess durch Ablassen und / oder Spülen. Wenn etwas schief gelaufen ist, durch Ablassen und / oder Spülen, Fluchen, Treten, einen Warmstart und schließlich durch einen Kaltstart versuchen oder den großen roten Knopf drücken (und auf den Programmierer schießen).

Ich habe auf dem Weg vielleicht übertrieben, aber versuche das nicht bei der Arbeit ...

Beispiel mit SORT. Details auf der Jobkarte sind sehr standortabhängig. Die Site-Richtlinien verbieten oder verhindern möglicherweise die Verwendung von INTRDR. Für die Verwendung von INTRDR ist möglicherweise eine bestimmte Klasse erforderlich. Wenn Ihre Website-Richtlinie die Verwendung verbietet, verwenden Sie sie nur, wenn Sie Ihre Habseligkeiten für einen Spaziergang in einem Pappkarton mitnehmen möchten.

Obwohl es gute Verwendungen für das INTRDR gibt, verwenden Sie es nicht für diesen Zweck . Sie werden nicht einmal eine Chance haben, Ihre Box zu bekommen.

//jobname JOB rest is to your site standards
//* 
//STEP0100 EXEC PGM=SORT 
//SYSOUT   DD SYSOUT=* 
//SORTOUT  DD SYSOUT=(,INTRDR) minimum required, site may require more 
//SYSIN    DD * 
  OPTION COPY 
//SORTIN   DD DISP=SHR,DSN=YOUR.LIBRARY.WITHJOB(JOBMEMBR) 

Andere Dienstprogramme sind verfügbar. Ein schnelles Programm wäre ebenfalls einfach zu erstellen. Lesen Sie einfach eine Datei und schreiben Sie eine Datei.

Wenn Sie möchten, dass ein Beispiel dafür nicht funktioniert, versuchen Sie Folgendes : http://ibmmainframes.com/viewtopic.php?p=282414#282414

Die herkömmliche Methode zum Kopieren eines Datasets besteht darin, das IBM-Dienstprogramm IEBGENER zu verwenden, wie ugoren in ihrem Kommentar anspielt.

Heutzutage wird IEBGENER an vielen Standorten auf ICEGENER "ausgerichtet" sein. ICEGENER wird, wenn möglich, IBMs DFSORT (oder seinen Rivalen SyncSort) verwenden, um eine Kopie zu erstellen, da die SORT-Produkte für E / A wesentlich besser optimiert sind als IEBGENER.

Ich schneide nur den Mittelsmann mit SORT aus.

Wenn Sie an einem IBM Mainframe-Standort arbeiten, kennen Sie das Format der JOB-Karte, die Sie verwenden sollten. Die minimale JOB-Karte ist, wie ich gezeigt habe, ohne Kommentar. Der Kommentar ist wichtig, da Sie möglicherweise beispielsweise Buchhaltungsinformationen angeben. Der Jobname wird wahrscheinlich ein standortspezifisches Format haben.

Einige Websites verbieten oder verhindern die Verwendung von INTRDR. Sei vorsichtig.

Auf einigen Sites können mehrere Jobs mit demselben Namen gleichzeitig ausgeführt werden. Sei vorsichtig.

Obwohl Sie als Systemprogrammierer keine solche Klasse einrichten können, sollten Sie nach einer Klasse suchen, die nur einen Initiator zulässt. Damit ist der Prozess ziemlich sicher - aber seien Sie sich absolut sicher, dass die Klasse wie beschrieben funktioniert. Prüfung. Nicht bei diesem Job.

Wenn Sie ein Programmierer des Systems sind, wissen Sie, dass Sie nichts außerhalb Ihres Zuständigkeitsbereichs tun dürfen. 'nuff sagte.

Bei einem Job mit demselben Namen, der zur selben Zeit zulässig ist, und einem einzelnen Initiator ist dies ein konstanter Strom von Jobstart / -ende, nächster Jobstart / -ende, bis Sie die Spool (eine andere schlechte Aufgabe) mit der Ausgabe von füllen Tausende von Jobs (oder keine Jobnummern mehr). Überwachen Sie eine JES-Konsole auf Warnmeldungen.

Tu das im Grunde nicht. Wenn Sie es tun, tun Sie es nicht auf einer Produktionsmaschine.

Mit ein wenig Nacharbeit werde ich eine andere Antwort für die Vorgehensweise unter einem anderen IBM Mainframe-Betriebssystem betrachten: z / VSE ... z / VSE verwendet JCL. z / OS verwendet JCL. Sie sind anders :-)

Python (72 Bytes)

import os
os.system('kill -9 %s && python %s' % (os.getpid(), __file__))

Könnte kleiner werden, denke ich. Erstens, indem Sie den Namen der Datei fest codieren (anstatt ihn zu verwenden __file__). Aber hier können Sie diesen Code in eine Datei einfügen und ausführen, egal wie er heißt :)

Windows Task Scheduler (.BAT)

Windows-Stapelskript. Erfüllt alle Herausforderungsanforderungen.

Soweit ich sehen kann, ist dies die einzige Windows-Lösung, die alle Anforderungen erfüllt und keine nicht standardmäßigen Abhängigkeiten aufweist (meine andere Lösung ist ähnlich, erfordert jedoch eine Kompilierung).

@ECHO OFF
SETLOCAL

schtasks /Delete /TN RestarterCL /F

ECHO Close this window now to stop.
TIMEOUT /T 5

FOR /f "tokens=1-2 delims=: " %%a IN ("%TIME%") DO SET /A now=%%a*60+%%b
SET /A start=%now%+1
SET /A starth=100+(%start%/60)%%24
SET /A startm=100+%start%%%60
SET /A end=%now%+3
SET /A endh=100+(%end%/60)%%24
SET /A endm=100+%end%%%60

schtasks /Create /SC ONCE /TN RestarterCL /RI 1 /ST %starth:~1,2%:%startm:~1,2% /ET %endh:~1,2%:%endm:~1,2% /IT /Z /F /TR "%~dpnx0"

ENDLOCAL

Das Programm verhält sich ähnlich wie meine C ++ / COM-Antwort .

Das Programm startet und registriert eine einmalige Aufgabe beim Windows-Taskplaner, um sich bis zu 60 Sekunden später selbst zu starten (Systemsteuerung -> Verwaltung -> Taskplaner, um anzuzeigen, die Aufgabe heißt "Neustarter"). Das Programm wird 5 Sekunden lang angehalten, damit Sie es beenden können, bevor die Aufgabe erstellt wird.

Verwendet die Befehlszeilenschnittstelle des Taskplaners schtasks.exe. Arithmetisch im Skript werden Zeitversätze berechnet, wobei die Zeit gültig und im HH: MM-Format bleibt.

Herausforderungsanforderungen:

• Startet sich selbst wieder, wenn Sie fertig sind. Ja. Die Aufgabe ist unmittelbar vor dem Beenden des Programms geplant.

• Es kann nicht mehr als eine Instanz des Programms gleichzeitig ausgeführt werden. Ja. Das Programm wird vollständig beendet und ~ 60 Sekunden lang nicht ausgeführt. Es wird vom Scheduler gestartet.

• Sie können jede Instanz ignorieren, die vom Benutzer während Ihres Zyklus manuell gestartet wurde. Ja, als Nebeneffekt der Verwendung eines konstanten Aufgabennamens.

• Solange garantiert ist, dass es wieder losgeht. Ja, vorausgesetzt, der Taskplaner wird ausgeführt und schtasks.exe ist vorhanden (beides gilt in Standard-Windows-Konfigurationen).

• Der Zyklus kann nur gestoppt werden, indem der Prozess abgebrochen wird. Ja, der Vorgang kann während des 5-Sekunden-Fensters abgebrochen werden, während er ausgeführt wird. Das Programm löscht die Aufgabe vor der Verzögerung von 5 Sekunden. Wenn Sie sie zu diesem Zeitpunkt beenden, verbleibt keine Streuaufgabe im Scheduler.

• Ihre Lösung sollte keinen Neustart der Umgebung beinhalten. Ja.

Hinweis: Aufgrund der eingeschränkten Befehlszeilenschnittstelle muss die Neustartzeit in Minuten angegeben werden, und der Task wird auf Laptops ohne eingesteckten Netzadapter nicht neu gestartet (Entschuldigung).

Unix-Shell

Ich habe noch nicht viele Lösungen gesehen, die auf einem nicht verwandten Programm basieren, um es neu zu starten. Aber genau dafür wurde das at(1)Dienstprogramm entwickelt:

echo "/bin/sh $0"|at now + 1 minute

Es ist schwierig, das laufende Programm tatsächlich zu erfassen, da es nur einmal pro Minute ausgeführt wird und so schnell beendet wird. Zum Glück atq(1)zeigt Ihnen das Dienstprogramm, dass es noch läuft:

$ atq
493     Fri Feb 21 18:08:00 2014 a breadbox
$ sleep 60
$ atq
494     Fri Feb 21 18:09:00 2014 a breadbox

Und atrm(1)ermöglicht es Ihnen, den Zyklus zu brechen:

$ atq
495     Fri Feb 21 18:10:00 2014 a breadbox
$ atrm 495
$ atq

Sie können 1 minutemit 1 hour, oder ersetzen 1 week. Oder geben Sie es 1461 days, um ein Programm zu haben, das alle 4 Jahre einmal ausgeführt wird.

Power Shell

Ich missbrauche (und verstoße möglicherweise) meine eigene Regel.

[System.Threading.Thread]::Sleep(-1)

Der Neustart dauert unendlich lange.
Es kann getötet werden, indem der Host-Prozess beendet wird.

Einfach abwarten und sehen;)

Bash

echo -e "$(crontab -l)\n$(($(date "+%M")+1)) $(date '+%H %e %m * /repeat.sh')" | crontab -

Speichern Sie diese Datei als repeat.sh im Verzeichnis / und erteilen Sie ihr die Ausführungsberechtigung. Es kann durch Löschen der Datei getötet werden

Dies funktioniert, indem Sie einen Eintrag in die crontab eingeben, um ihn 1 Minute später auszuführen.

Visual Base 6 :)

Sub Main:Shell "cmd ping 1.1.1.1 -n 1 -w 500>nul&&"""&App.Path &"\"&App.EXEName& """":End Sub

Erstellen Sie zum Ausführen ein neues Projekt, fügen Sie ein Modul mit diesem Code hinzu, setzen Sie das Startobjekt auf "Sub Main", kompilieren Sie die ausführbare Datei und führen Sie sie aus.

Mehr lesbare Version:

Sub Main()
    Call Shell("cmd ping 1.1.1.1 -n 1 -w 3000 > nul && """ & App.Path & "\" & App.EXEName & """")
End Sub

HTML / JAVASCRIPT

HTML-DATEI a.html

<script>window.location = "a.html"</script>

Bash

Länger als es sein muss, aber ich bin müde und es ist mir egal :)

while true; do sleep 1; done; bash $0;

Sie sagten, dass es sich selbst neu starten muss, wenn es fertig ist. Sie haben nicht ausdrücklich gesagt, dass es dies wiederholt oder auf unbestimmte Zeit tun muss. Sie sagten auch, dass niemals zwei Instanzen gleichzeitig ausgeführt werden sollten ... dies wird niemals der Fall sein. ;)

Es gibt eine Vielzahl von Möglichkeiten, dies zu tun. Mein persönlicher Favorit wäre, so etwas wie ein Paket an einen entfernten Ort zu senden und dann (über eine beliebige Anzahl von Methoden) die Antwort den Prozess auslösen zu lassen.

Android: Ein Alarm startet die Aktivität nach 1 Sekunde neu

public class AutoRestart extends Activity
{

@Override
public void onCreate()
{
    finish();
}

@Override
public void onDestroy() {

    Intent restartServiceIntent = new Intent(getApplicationContext(), this.getClass());
    restartServiceIntent.setPackage(getPackageName());

    PendingIntent restartServicePendingIntent = PendingIntent.getService(getApplicationContext(), 1, restartServiceIntent, PendingIntent.FLAG_ONE_SHOT);
    AlarmManager alarmService = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
    alarmService.set(
            AlarmManager.ELAPSED_REALTIME,
            SystemClock.elapsedRealtime() + 1000,
            restartServicePendingIntent);

    super.onDestroy();
}

}

C + MPI-Umgebung

mpifork.c:

#include <stdio.h>

main(int argc, char * argv[])
{
    srand(time(NULL));
    int host = rand()%(argc-1)+1;
    FILE * logFile = fopen("mpifork.log", "a");
    if(logFile == NULL){
        fprintf(stderr, "Error: failed to open log file\n");
    } else {
        fprintf(logfile, "Jumping to %s\n", argv[host]);

        char * args[argc+5];
        args[0] = "mpirun";
        args[1] = "-H";
        args[2] = argv[host];
        args[3] = argv[0];
        for(host = 0; host < argc-1; host++) args[host+4] = argv[host+1];
        args[argc+3] = NULL;

        execvp("mpirun", args);
        fprintf(stderr, "exec died\n");
        perror("execvp");
    }
}

Sie müssen OpenMPI oder eine andere MPI-Implementierung installiert haben. Kompilieren mit

mpicc -o mpifork mpifork.c

Nun, da ich darüber nachdenke, gibt es keinen Grund, warum Sie mpicc - gcc verwenden müssen oder welcher Compiler auch immer funktioniert. Sie müssen nur mpirun haben.

gcc -o mpifork mpifork.c

Um es auszuführen, sollten Sie wahrscheinlich den vollständigen Pfadnamen und eine Liste der Hosts angeben. Zum Beispiel habe ich einige Einträge in / etc / hosts hinzugefügt, die alle auf localhost zeigten, und habe es folgendermaßen ausgeführt:

/home/phil/mpifork localhost localhost1 localhost2 localhost3 localhost4

Die ausführbare Datei muss sich auf jedem Computer, auf dem Sie diese ausführen möchten, im selben Verzeichnis befinden.

Wenn Sie böse sein möchten, können Sie diesen Start stattdessen auf jedem Computer ausführen, indem Sie die vollständige Liste der Hosts in die Befehlszeile einfügen args. Das würde auf jedem Rechner immer wieder eine Kopie von sich selbst erzeugen - eine Cluster-Gabelbombe.

In dieser Form bin ich mir jedoch ziemlich sicher, dass dies den Regeln entspricht.

JavaScript

Ohne "ins Netzwerk gehen", wenn es nicht nötig ist :-) Mit der Event-Loop-Planung von JavaScript können wir sehr einfach Programme schreiben, die die gegebenen Anforderungen erfüllen:

(function program() {
    // do what needs to be done
    setTimeout(program, 100);
})();

Dies "startet" die programFunktion mit einer Geschwindigkeit von 10-mal pro Sekunde neu. JavaScript garantiert, dass nur eine Aufgabe gleichzeitig ausgeführt wird, und startet die Umgebung nicht neu, wie unter "Seite neu laden" beschrieben.

x86-Assembly

Nicht ganz sicher, ob dies Ihren Kriterien entspricht, da es keinen neuen Prozess erzeugt, aber hier ist es trotzdem.

Das Programm zeigt ein Meldungsfeld an, weist Speicher zu, kopiert seinen eigenen Codeabschnitt in den zugewiesenen Speicher und springt dann zu dieser Stelle, wobei der Zyklus von vorne beginnt. Es sollte so lange laufen, bis malloc ausfällt.

format PE GUI 4.0
entry a

include 'include/win32a.inc'

section '.text' code readable executable

    a:
        push    0
        push    _caption
        push    _message
        push    0
        call    [MessageBoxA]

        push    b-a
        call    [malloc]

        push    b-a
        push    a
        push    eax
        call    [memcpy]

        call    eax
    b:

section '.data' data readable writeable

    _caption db 'Code challenge',0
    _message db 'Hello World!',0

section '.idata' import data readable writeable

    library user,'USER32.DLL',\
        msvcrt,'msvcrt.dll'

    import user,\
        MessageBoxA,'MessageBoxA'

    import msvcrt,\
        malloc,'malloc',\
        memcpy,'memcpy'

Mit fasm zusammengestellt.

Linux upstart init

Angesichts der strengsten Lektüre der Frage halte ich dies für unmöglich. Im Wesentlichen wird darum gebeten, dass ein Programm spontan gestartet wird, ohne dass andere Programme ausgeführt werden.

Es gibt einige atund chron-basierte Antworten, jedoch mit der strengsten Lesart, atdund anacrones handelt sich um Ergänzungsprogramme, die ständig ausgeführt werden, so dass sie möglicherweise disqualifiziert werden.

Ein ähnlicher Ansatz, aber etwas niedriger, ist die Verwendung von Linux init. Fügen Sie als Root diese .conf-Datei hinzu zu /etc/init/:

beschreibung "für immer"

starte auf Runlevel [2345]
Stopp auf Runlevel [! 2345]

respawn

Exec Schlaf 10

Dann müssen initSie die .conf-Dateien erneut lesen:

sudo telinit 5

Dadurch wird ein sleepProzess gestartet , der 10 Sekunden lang andauert und dann beendet wird. initwird dann wieder erscheinen, sleepsobald es feststellt, dass das vorherige verschwunden ist.

Natürlich wird dies immer noch initals Zusatzprogramm verwendet. Man könnte argumentieren, dass dies initeine logische Erweiterung des Kernels ist und in jedem Linux immer verfügbar sein wird.

Wenn dies nicht akzeptabel ist, würde ich als nächstes auf einer niedrigeren Ebene ein Kernelmodul erstellen, das einen Userspace-Prozess wieder aufbaut (nicht sicher, wie einfach das ist). Hier kann argumentiert werden, dass der Kernel kein Prozess und daher kein Programm (Zusatz) ist. Andererseits ist der Kernel aus Sicht der CPU ein eigenständiges Programm.

TI-BASIC: 5 Zeichen

nennen prgmA

:prgmA