एक कार्यक्रम जो समाप्त होता है लेकिन कभी समाप्त नहीं होता है [बंद]

Question

एक कार्यक्रम लिखें जो खत्म होने पर खुद को फिर से शुरू करता है।

एक ही समय में चल रहे कार्यक्रम का एक से अधिक उदाहरण नहीं होना चाहिए। जरा भी समय के लिए नहीं।

आप अपने चक्र के दौरान उपयोगकर्ता द्वारा मैन्युअल रूप से शुरू किए गए किसी भी उदाहरण को अनदेखा कर सकते हैं। लेकिन आपका कोड आपके पुनरारंभ चक्र में ऐसा नहीं करना चाहिए।

कार्यक्रम किसी भी समय के बाद शुरू हो सकता है, जब तक कि यह गारंटी है कि यह फिर से शुरू होता है।

चक्र को रोकने का एकमात्र तरीका प्रक्रिया को मारना है।

आपके समाधान में पर्यावरण को फिर से शुरू करने (जिसमें प्रोग्राम चल रहा है, ओएस, मशीन, वीएम, शेल आदि शामिल हैं) शामिल नहीं होना चाहिए। केवल आपके कार्यक्रम को पुनः आरंभ करने की अनुमति है।

Comments

क्या यह सिर्फ execलिनक्स में नहीं है?

— mniip

मैं अभी इसे लिखने के लिए थोड़ा आलसी हूं, लेकिन मेरा सबमिशन (विंडोज़ के लिए) होगा: "रजिस्ट्री को संपादित करें ताकि मेरे स्टार्टअप पर बूट हो। रन shutdown -r -t 0 -f"।

— क्रंचर

हालांकि इस प्रक्रिया को मारना आपके चक्र को नहीं मारेगा।

— माइक्रोबियन

मुझे बस एहसास हुआ: अगर मैं एक वायरस लिखना चाहता हूं और यह नहीं जानता कि कैसे, मैं 1) StackOverflow में जा सकता हूं, तो पूछें कि कैसे। हर किसी से नफरत करें और शायद सवाल बंद हो जाएगा। या 2) कोड गोल्फ पर जाएं, दूसरों से पूछें कि वे इसे कैसे करेंगे। से चयन करने के लिए कुछ रचनात्मक उत्तर प्राप्त करें, और यह सवाल इतना लोकप्रिय है कि यह नेटवर्क-वाइड "हॉट" सूची में हो जाता है। मुआ हा हा हा हा।

— rumtscho

@rumtscho तुम्हें पता है, यह एक अच्छी सामान्य रणनीति है। ठीक है, मेरी अगली चुनौती के लिए, आइए देखें कि मेरी डेस्क पर बैठे प्रोटोटाइप डिवाइस के लिए सबसे छोटा फर्मवेयर कौन लिख सकता है जो लिंक किए गए दस्तावेज़ में सभी आवश्यकताओं को पूरा करता है। इसे मसाला देने के लिए, यह सुबह 8 बजे तक किया जाना चाहिए। चले जाओ!

— जेसन सी

Answer 1

बैश स्क्रिप्ट, 3 चार्ट्स (सबसे छोटा, संभवतः सबसे सुरुचिपूर्ण, हालांकि भर्ती रूप से विवादास्पद)

$0&

बस पृष्ठभूमि में खुद का एक नया उदाहरण (नई प्रक्रिया) रखता है, फिर क्विट करता है। नया उदाहरण संभावना शेड्यूलर रन-कतार में रहेगा जब तक कि पिछला उदाहरण नहीं है।

चेतावनी - यह कठिन है kill, क्योंकि पीआईडी ​​लगातार बदल रहा है। अस्थायी रूप से स्क्रिप्ट फ़ाइल का नाम बदलना संभवतः चक्र को तोड़ने का सबसे सरल तरीका है।

एकल-कोर प्रणाली मान ली गई है। बेशक यह आधुनिक नंगे-धातु हार्डवेयर पर लिनक्स के साथ यथार्थवादी नहीं है, लेकिन वीएम में चलने पर यह आसानी से कॉन्फ़िगर करने योग्य है। हम संभवत: एक समान चाल का उपयोग कर प्राप्त कर सकते हैं taskset, लेकिन यह 3-चार समाधान के प्रभाव को कम करेगा।

यह उत्तर नियमों को थोड़ा झुकाता है कि यह "चल" का एक विशिष्ट अर्थ लागू करता है। ऐसे क्षण आएंगे जब नई प्रक्रिया fork()एड की गई होगी और पुरानी प्रक्रिया अभी भी जीवित है - अर्थात एक से अधिक पीआईडी ​​का निरीक्षण करना संभव हो सकता है। हालांकि सीपीयू चक्रों की प्रतीक्षा के लिए नई प्रक्रिया को लिनक्स शेड्यूलर रन-क्यू पर रखा जाएगा, जबकि मौजूदा प्रक्रिया निष्पादित करना जारी रखेगी। इस बिंदु पर, मौजूदा प्रक्रिया द्वारा किए जाने वाले सभी कार्य bashस्वयं के लिए हैं exit()। यह समय की एक निश्चित राशि लेता है, हालांकि मुझे पूरा विश्वास है कि यह वर्तमान समय / समय से पहले किया जाएगा। सहायक साक्ष्य तथ्य यह है कि bashशुरू होता है और मेरे वीएम पर 2ms में नीचे बन्द हो जाता है:

$ समय बैश -c:

असली 0m0.002s
उपयोगकर्ता 0m0.000s
sys 0m0.000s
$ 

आगे के समर्थन साक्ष्य कि नई प्रक्रिया वास्तव में तब तक नहीं चलती है जब तक कि पिछली प्रक्रिया को पूरा नहीं किया जाता है strace:

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

आउटपुट में, हम देखते हैं कि मूल प्रक्रिया में PID 6929 है। हम fork()कॉल (वास्तव में clone()) देख सकते हैं , जो 6930 का नया PID लौटाता है। इस बिंदु पर 2 PID हैं, लेकिन वर्तमान में केवल 6929 चल रहा है:

6929 12: 11: 01.031398 क्लोन (child_stack = 0, झंडे = 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 पढ़ा (255, "", 4) = 0
6929 12: 11: 01.031907 से बाहर निकलें_ग्रुप (0) =?
6930 12: 11: 01.032016 करीब (255) = 0
6930 12: 11: 01.032052 rt_sigprocmask (SIG_SETMASK, [], NULL, 8) = 0

पूर्ण straceउत्पादन यहाँ।

हम देख सकते हैं कि 6930 पूरी तरह से होने तक कोई भी सिस्टम कॉल जारी नहीं करता है। यह मान लेना उचित है कि इसका मतलब 6930 तब तक नहीं चलता है जब तक 6929 नहीं हो जाता। perfउपयोगिता साबित करने के लिए यह परम तरीका होगा।

Comments

"पुनरारंभ होता है ..., फिर क्विट करता है", इसलिए एक से अधिक उदाहरण एक ही समय में चल रहे हैं?

— माइक्रोबियन

"... सिंगल कोर पर" - हां, मैं भी अनुमान लगाऊंगा। कई-कोर पर, आप संभावित रूप से कई देखने में सक्षम हो सकते हैं।

— blabla999

यदि यह कोड-गोल्फ टैग किया गया था, तो यह निश्चित रूप से जीत जाएगा! +1

— जॉन ओडम

@DigitalTrauma आप अपने आप को बंद करने के लिए बैश होने में कितना समय लेती हैं, इस बारे में बहुत बड़ी धारणाएँ हैं। शीर्ष आपको कुछ भी नहीं बताता है - यह केवल हर एक बार (दसियों) सेकंड में अपडेट होता है, लेकिन आप प्रति सेकंड कई प्रक्रियाओं को जन्म दे रहे हैं।

— डेविड रिचेर्बी

@DavidRicherby - आप बिल्कुल सही हैं - topयहाँ उपयोग करने के लिए सही उपकरण नहीं है। हालाँकि मैं देख रहा हूं कि time bash -c :मेरे उबंटू वीएम पर केवल 2ms लगते हैं, इसलिए मुझे लगता है bashकि इसके शेड्यूलिंग क्वांटम होने से पहले इसके बंद होने की उम्मीद करना अनुचित नहीं होगा ।

— डिजिटल ट्रामा

Answer 2

समाधान 1

PHP, 32 वर्ण

यह हेडर भेजता है और फिर यह बंद हो जाता है। 3 सेकंड के बाद, पृष्ठ पुनः लोड हो जाता है।

a.php फाइल करें

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

हेडर भेजे जाने से पहले, या केवल ब्राउज़र को मारकर पृष्ठ के निष्पादन को समाप्त करके इसे रोका जा सकता है।

---

समाधान २

PHP, 2 पृष्ठ

आइए दो फाइलों पर दो अलग-अलग कार्यक्रमों पर विचार करें। दो फ़ाइलें एक ही फ़ोल्डर में हैं।

a.php फाइल करें

header("Location:b.php");

फ़ाइल b.php

header("Location:a.php");

हेडर भेजे जाने से पहले पृष्ठों में से एक को समाप्त करना कार्यक्रम को समाप्त करता है (ब्राउज़र काम करता है, बहुत अधिक मार रहा है)।

यहाँ एक ही कार्यक्रम में है

ASP.NET

फ़ाइल। aaspx

Response.Redirect("b.aspx")

फ़ाइल b.aspx

Response.Redirect("a.aspx")

Comments

यह एक अच्छा उपाय है। मुझे उम्मीद है कि अन्य लोग इससे अलग जवाब देंगे। इसलिए मैंने इसे लोकप्रियता की प्रतियोगिता के रूप में रखा।

— माइक्रोबियन

आपका 3 दूसरा पुनः लोड उत्तर मान्य है या नहीं, मैं इसे php विशेषज्ञों पर छोड़ता हूं। मुझे लगता है कि यह मान्य हो सकता है, क्योंकि यह वह ब्राउज़र है जो आपके php का इंतजार कर रहा है (मैं कोई विशेषज्ञ नहीं हूं)।

— माइक्रोबियन

जबकि तकनीकी रूप से PHP एक वेब सर्वर के मॉड्यूल के रूप में चलाया जाता है और आपके वेब सर्वर को पुनरारंभ नहीं किया गया है, मुझे लगता है कि यदि आप एक स्क्रिप्ट के रूप में एक .php फ़ाइल और स्क्रिप्ट को कई बार चलाते हैं तो यह मान्य है।

— ट्विनाइट

@TwiNight प्रतिक्रिया के लिए धन्यवाद, मैं इसकी सराहना करता हूं :)

— वीरोस

आपके दूसरे समाधान के लिए, क्या ब्राउज़र एक रीडायरेक्ट लूप का पता नहीं लगाएगा और अपने आप बंद हो जाएगा? thedan1984.com/wp-content/uploads/2012/02/…

— Ajedi32

Answer 3

श

echo $PWD/$0 | at tomorrow

यह किसी भी Posix- कंप्लेंट सिस्टम पर काम करेगा।

इसे मारने के लिए, फ़ाइल को हटा दें या उपयोग करें atrm।

Answer 4

दे घुमा के

exec "$0"

execनई प्रक्रिया बनाए बिना शेल को बदल देता है। यह सुनिश्चित करता है कि दूसरा उदाहरण नहीं हो सकता है।

Comments

बेहतर है इसे अंदर रखो ~/.bash_profile!

— yegle

@yegle: जब इसे सॉर्ट किया $0जाता है, तो इसका परिणाम सिंटैक्स त्रुटि के रूप में होगा। -bash.bash_profile

— डेनिस

उफ़, आप सही हैं।

— 3

exec ${0##-}में ~/.bash_profileकाम करता है :-)

— yegle

Answer 5

विंडोज टास्क शेड्यूलर (मूल)

सी ++। COM प्रोग्रामिंग का एक बुरा सपना। सभी चुनौतियों को पूरा करता है।

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

}

MSVC के साथ संकलित करें (या यदि आपके पास सभी निर्भरता हैं तो MinGW GCC)।

प्रोग्राम विंडोज टास्क शेड्यूलर के साथ 5 सेकंड बाद (कंट्रोल पैनल -> एडमिनिस्ट्रेटिव टूल्स -> टास्क शेड्यूलर को देखने के लिए, टास्क को "रिस्टोरर" नाम से शुरू करने के लिए एकबारगी टास्क शुरू करेगा और रजिस्टर करेगा)। यह कार्य करने से पहले आपको इसे मारने का मौका देने के लिए कार्यक्रम 5 सेकंड के लिए रुक जाएगा।

चुनौती आवश्यकताएँ:

• खत्म होने पर खुद को फिर से शुरू करता है। हाँ। कार्यक्रम से बाहर निकलने से ठीक पहले टास्क निर्धारित है।

• एक ही समय में चल रहे कार्यक्रम का एक से अधिक उदाहरण नहीं। हाँ। कार्यक्रम पूरी तरह से बाहर निकलता है और 5 सेकंड के लिए नहीं चलता है। यह शेड्यूलर द्वारा शुरू किया गया है।

• आप अपने चक्र के दौरान उपयोगकर्ता द्वारा मैन्युअल रूप से शुरू किए गए किसी भी उदाहरण को अनदेखा कर सकते हैं। हां, निरंतर कार्य नाम का उपयोग करने के साइड-इफेक्ट के रूप में।

• जब तक यह गारंटी है कि यह फिर से शुरू होता है। हाँ, बशर्ते कि टास्क शेड्यूलर चल रहा हो (यह एक मानक विंडोज कॉन्फ़िगरेशन में है)।

• चक्र को रोकने का एकमात्र तरीका प्रक्रिया को मारना है। हां, इस प्रक्रिया को चलाने के दौरान 5 सेकंड विंडो के दौरान मारा जा सकता है। कार्यक्रम 5 सेकंड की देरी से पहले कार्य को हटा देता है, इस समय इसे मारना शेड्यूलर में एक आवारा कार्य नहीं छोड़ेगा।

• आपके समाधान में पर्यावरण को पुनः आरंभ करना शामिल नहीं होना चाहिए हाँ।

वैसे, अगर किसी ने कभी सोचा है कि विंडोज एप्लिकेशन इतना अस्थिर क्यों हुआ करते हैं (.NET और C # के आगमन से पहले), यह एक कारण है। आवश्यकता से निपटने में त्रुटि की मात्रा (मैंने इसे शामिल किया था), संसाधन प्रबंधन, और क्रियाशीलता बहुत ही त्रुटि वाली स्थितियों को सेट करती है यदि कोई प्रोग्रामर थोड़ा सा भी आलसी है (उपरोक्त कोड बेहद आलसी है)।

एक बहुत आसान और छोटा विकल्प schtasks.exe आह्वान करना है। मैंने इसके साथ एक संस्करण प्रस्तुत किया है । साथ ही स्क्रिप्ट में भी।

Answer 6

बीबीसी बेसिक - स्नो पेट्रोल को एक श्रद्धांजलि

Bbcbasic.co.uk पर एमुलेटर

यह थोड़ा अलग है। यह "रन" गीत के एक श्लोक को प्रिंट करता है और कॉर्ड्स का एक आर्पीगियो निभाता है ताकि आप साथ गा सकें। यह इस तथ्य से प्रेरित था कि निष्पादित करने के लिए कमांड (और इसलिए कार्यक्रम की अंतिम पंक्ति) निश्चित रूप से RUN है।

कार्यक्रम की शुरुआत में सभी चर साफ हो जाते हैं, इसलिए यह अगले पुनरावृत्ति के लिए स्क्रीन के रंग को पीछे ले जाता है ताकि यह तय किया जा सके कि आगे क्या छपना है।

    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 (4 विभिन्न स्क्रीन शॉट्स का असेंबल)

Comments

"साझा मेमोरी" विकल्प के रूप में रंग समाधान के लिए +1।

— जोहान्स एच।

Answer 7

HTML / जावास्क्रिप्ट:

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

कोड उस पृष्ठ के विनाश को चालू करता है जिस पर वह चल रहा है, फिर जब ब्राउज़र पृष्ठ को नए सिरे से लोड करता है तो स्वयं का एक और उदाहरण फिर से बन जाता है।

AFAIK, पृष्ठ को चलाने के लिए टैब को मारने का एकमात्र तरीका है।

संपादित करें: लोकप्रिय अनुरोध के अनुसार, एक मान्य HTML5 कोड:

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

Comments

@ जैसन आई असहमत। मुझे लगता है कि उचित पृष्ठों को ऐनक के साथ पालन करना चाहिए, लेकिन लोकप्रियता-प्रतियोगिता एस को उचित माना जाता है, क्या वे हैं? : D इतना +1, मुझे वास्तव में यह पसंद है।

— यो '

Answer 8

सी

यह प्रोग्राम बहुत सारे मालवेयर की तरह काम करता है। बंद होने से ठीक पहले, यह / tmp निर्देशिका में एक शेल स्क्रिप्ट बनाता है। यह शेल स्क्रिप्ट शुरू करने की कोशिश करता है, जो मूल प्रोग्राम को बंद कर देता है और मूल पीआईडी ​​को रद्द कर देता है। थोड़े समय (2 सेकंड) के बाद शेल स्क्रिप्ट प्रोग्राम के साथ एक नई प्रक्रिया शुरू करती है। संक्षिप्तता के लिए, कार्यक्रम स्थान '/ tmp / neverend /' के रूप में हार्ड-वायर्ड है।

#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]);
}

एक समय में केवल एक 'नेवरेंड' प्रक्रिया चल रही है। प्रत्येक नई प्रक्रिया को एक नया पीआईडी ​​मिलता है। इसे मारने का सबसे आसान तरीका निष्पादन योग्य हटाना है। यदि आप इसे अधिक घातक बनाना चाहते हैं, तो आप निष्पादन योग्य और स्क्रिप्ट दोनों को कॉपी कर सकते हैं ताकि यह सुनिश्चित किया जा सके कि किसी भी समय डिस्क पर प्रोग्राम पर कई प्रतियां हैं।

Comments

मैं और अधिक अभिनव जवाब देखने की उम्मीद कर रहा हूं। 'पूरक कार्यक्रमों' के बारे में प्रश्न के लिए टिप्पणियां देखें। मेरे लिए, एक पूरक कार्यक्रम आपके कार्यक्रम का एक हिस्सा है जो चारों ओर लटका हुआ है।

— माइक्रोबियन

फोर्किंग का मतलब है कि आपके पास एक ही समय में चलने वाली प्रक्रिया के दो उदाहरण होंगे, भले ही वे अलग-अलग चीजें कर रहे हों।

— बैरी फ्रूटमैन

@BarryFruitman से बचना आसान है, हालांकि, वास्तव में दो अलग-अलग निष्पादनों का उपयोग करके। यह तब मान्य है, लेकिन कम सुरुचिपूर्ण तरीके से।

— जोहान्स एच।

मुझे लगता है कि system()अगर आप नियमों को /bin/shपूरक कार्यक्रम के रूप में एक कांटा + निष्पादन की गिनती नहीं करते हैं तो आप उपयोग कर सकते हैं ।

— जेसन सी

Answer 9

पर्ल

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

स्क्रिप्ट खुद को मारने के लिए एक सिस्टम कमांड जारी करती है, और परिणाम को स्वयं के दूसरे उदाहरण में पाइप करती है। क्रॉस प्लेटफ़ॉर्म कारणों से पर्ल इंटरप्रेटर का उपयोग हत्या करने के लिए किया जाता है।

स्क्रिप्ट को हटाकर पागलपन को रोकें।

Answer 10

अटारी 8-बिट बेसिक

1L.:R.

इसके लिए टोकन

1 LIST : RUN

आंतरिक रूप से यह आंतरिक संरचनाओं को साफ कर रहा है, अनिवार्य रूप से सूची से फिर से चलाने से पहले, कार्यक्रम को मिटा देता है।

यह मौलिक रूप से अलग है:

1L.:G.1

जो टोकन के लिए:

1 LIST : GOTO 1

यह एक बुनियादी अनंत लूप है। जब आप उन्हें चलाते हैं, तो आपको गति में अंतर दिखाई देता है (पहले धीमा है)।

Comments

मैं बिल्कुल स्पष्ट नहीं हूं कि कार्यक्रम निष्पादन के दौरान "सूची" किसी भी इंटरनल संरचनाओं को क्यों साफ करेगी। मुझे लगता है कि अटारी में एक कीबोर्ड बफर है, इसलिए कोई भी इस कार्यक्रम को सूचीबद्ध कर सकता है, इसे चलाने के लिए कीस्ट्रोक्स को सामान कर सकता है, और इसे "रिटाइप" करने के लिए तैनात कर्सर के साथ "नया" करें।

— सुपरकैट

@ सुपरकैट - लिस्ट नहीं, रुन करता है।

उस तर्क से, कोई "सूची" को छोड़ सकता है। दूसरी ओर, अगर प्रोग्राम में कुछ गाड़ी के रिटर्न के साथ कीबोर्ड बफर भर जाता है, तो प्रोग्राम के बाद "NEW" डालें और स्क्रीन पर सही स्पॉट पर "RUN", कर्सर को होम कर दें और बाहर निकल जाएं, यह वास्तव में सही नहीं होगा। और अपने आप ही पुनः टाइप करें।

— सुपरकाट

@ सुपरकैट - बिना LIST, आप इसे चालू नहीं देखेंगे। मैंने चुना LISTक्योंकि इसमें सबसे छोटा इनपुट है L.। मुझे इसे कीबोर्ड बफर में डालने का विचार पसंद है, यह निश्चित रूप से काफी छोटा है!

क्या मुझे ठीक से याद है कि कमोडोर मशीनों की तरह अटारी, जब आप धक्का देते हैं तो स्क्रीन से पाठ को पढ़ता है Return? कीबोर्ड बफर कितना बड़ा है? VIC-20 और C64 पर, यह दस बाइट्स है। एक प्रोग्राम जो कीबोर्ड बफर को लोड करने के लिए पर्याप्त चुटकुले करता है, शायद कीबोर्ड बफर में फिट नहीं होगा, लेकिन मैंने ऐसे प्रोग्राम लिखे हैं जो स्क्रीन के बदलावों को प्रिंट करके RUNऔर कुछ Returnकीस्ट्रोक्स के साथ खुद को प्रिंट करके संशोधित करेंगे । इस तरह की चीजें 64 पर विशेष रूप से उपयोगी थीं क्योंकि इसमें [IIRC] INकमांड नहीं था अटारी को प्रोग्राम में लाइनों को मर्ज करने के लिए।

— सुपरकैट

Answer 11

आईबीएम मेनफ्रेम रनिंग जेड / ओएस पर, आप एक उपयोगिता चलाते हैं जो किसी डेटासेट (फ़ाइल) को किसी अन्य डेटासेट (फ़ाइल) में कॉपी करता है। इनपुट जेसीएल (जॉब कंट्रोल लैंग्वेज) का स्रोत है जिसे आपने इसे चलाने के लिए प्रस्तुत किया है। आउटपुट आंतरिक रीडर (INTRDR) है। आपको यह भी सुनिश्चित करना होगा कि आपका सिस्टम कई समान जॉबनामों को चलाने की अनुमति नहीं देता है। एक नौकरी-वर्ग का उपयोग करने के लिए अच्छा है जिसमें केवल एक सर्जक है (वह स्थान जहां एक JOB बैच में चल सकता है)।

इसमें कोई PID शामिल नहीं हैं (z / OS में), इसलिए चुनौती सेट विफल हो जाता है।

आप जल निकासी और / या फ्लशिंग द्वारा प्रक्रिया को रोकते हैं। अगर कुछ गलत हो गया है, और / या निस्तब्धता, शपथ ग्रहण, लात मारना, एक गर्म शुरुआत का प्रयास करना और अंत में एक कोल्ड स्टार्ट या बिग रेड बटन को मारना (और प्रोग्रामर को गोली मारना)।

मैं रास्ते में अतिरंजित हो सकता है, लेकिन काम पर यह कोशिश मत करो ...

उदाहरण SORT का उपयोग करते हुए। JOB कार्ड पर विवरण बहुत साइट पर निर्भर हैं। साइट नीति INTRDR के उपयोग को या तो रोक सकती है या रोक सकती है। INTRDR का उपयोग करने के लिए एक विशिष्ट वर्ग की आवश्यकता हो सकती है। यदि आपकी साइट नीति इसका उपयोग करने से मना करती है तो इसका उपयोग न करें तब तक जब तक आप कार्डबोर्ड बॉक्स में टहलने के लिए अपना सामान नहीं लेना चाहते।

यद्यपि INTRDR के लिए अच्छे उपयोग हैं, इस उद्देश्य के लिए इसका उपयोग न करें । आपको अपना बॉक्स प्राप्त करने का भी मौका नहीं मिलेगा।

//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) 

अन्य उपयोगिताओं उपलब्ध हैं। एक त्वरित कार्यक्रम भी करना आसान होगा, बस एक फ़ाइल पढ़ें, एक फ़ाइल लिखें।

यदि आप इस गलत होने का उदाहरण चाहते हैं, तो प्रयास करें: http://ibmmainframes.com/viewtopic.php?p=282414#282414

डेटासेट की प्रतिलिपि बनाने का पारंपरिक तरीका आईबीएम उपयोगिता IEBGENER का उपयोग करना है, जैसा कि उनकी टिप्पणी में सभी दृष्टिकोण हैं।

हालांकि, इन दिनों, कई साइटों में आईजीबीईएन को आईजीबीएनईआर "अलियास" होगा। ICEGENER, यदि यह कर सकता है, तो एक प्रतिलिपि करने के लिए IBM के DFSORT (या उसके प्रतिद्वंद्वी SyncSort) का उपयोग कर सकता है, क्योंकि SORT उत्पादों को IEBGENER की तुलना में IO के लिए बहुत अधिक घृणित रूप से अनुकूलित किया गया है।

मैं सिर्फ SORT का उपयोग करके मध्यम-पुरुष को काट रहा हूं।

यदि आप एक आईबीएम मेनफ्रेम साइट पर काम करते हैं, तो आपको JOB कार्ड का प्रारूप पता होता है जिसे आपको उपयोग करना चाहिए। न्यूनतम JOB कार्ड जैसा कि मैंने दिखाया है, बिना टिप्पणी के। टिप्पणी महत्वपूर्ण होगी, क्योंकि उदाहरण के लिए, आपको लेखांकन जानकारी की आपूर्ति की जानी चाहिए। नौकरीनाम में संभवतः एक साइट-विशिष्ट प्रारूप होगा।

कुछ साइट प्रतिबंध, या रोकथाम, INTRDR का उपयोग। ज़रा बच के।

कुछ साइटें एक ही समय पर एक ही नाम से कई कार्य करने देती हैं। ज़रा बच के।

हालाँकि जब तक आप सिस्टम के प्रोग्रामर नहीं होते हैं तब तक आप ऐसी क्लास नहीं लगा सकते हैं, आपको एक ऐसे वर्ग की तलाश करनी चाहिए जो केवल एक सर्जक को अनुमति देता है। इसके साथ, यह प्रक्रिया काफी सुरक्षित है - लेकिन इस बारे में पूरी तरह सुनिश्चित रहें कि कक्षा वर्णित के अनुसार काम कर रही है। परीक्षा। इस नौकरी के साथ नहीं।

यदि आप एक सिस्टम प्रोग्रामर हैं, तो आप अपने रीमिट के बाहर कुछ भी नहीं करना जानते हैं। 'निफ ने कहा।

एक ही समय में एक ही नाम के साथ एक नौकरी और एक ही सर्जक के साथ, यह जॉब स्टार्ट / फ़िनिश अगली जॉब स्टार्ट / फ़िनिश की एक सतत स्ट्रीम होगी - जब तक कि आप आउटपुट से स्पूल (एक और बुरी चीज़) नहीं भरेंगे। हजारों नौकरियां (या नौकरी से बाहर भागना)। चेतावनी संदेशों के लिए एक JES कंसोल देखें।

असल में, यह मत करो। यदि आप ऐसा करते हैं, तो इसे प्रोडक्शन मशीन पर न करें।

थोड़ा ब्रश करने के साथ, मैं एक और आईबीएम मेनफ्रेम ऑपरेटिंग सिस्टम, जेड / वीएसई ... जेडसीई / जेडसीई जेसीएल का उपयोग करने के तरीके पर एक और उत्तर देने पर विचार करूंगा। z / OS JCL का उपयोग करता है। वे भिन्न हैं :-)

Comments

विचार अच्छा लग रहा है, लेकिन यह एक जवाब नहीं है। हमें JCL - JOB, EXEC और DD दिखाएं - फिर यह एक उत्तर होगा।

— बदसूरत

एक भयानक लंबे समय के लिए नौकरी प्रस्तुत नहीं की है, इसलिए मुझे यकीन नहीं है कि इसका क्या बनाना है। यदि लापता भाग सिर्फ स्थानीय अनुकूलन हैं, तो ठीक है। लेकिन अगर आप एक दुरुपयोग को रोकने के लिए सामान छिपाते हैं, तो अपना मन बना लें - वास्तविक चीज़ पोस्ट करें, या कुछ भी पोस्ट न करें। पुनश्च हम IEBGENERतो वापस कॉपी करने के लिए इस्तेमाल किया ।

— बदसूरत

@ यूग्रेन आगे का अपडेट, जिसमें IEBGENER को कार्य के लिए नहीं चुना गया था, की व्याख्या भी शामिल है। JOB स्टेटमेंट पर टिप्पणी पाठ को हटाने के लिए आवश्यक JCL को चलाने के लिए आवश्यक है, लेकिन यह पर्याप्त JCL है स्थानीय साइट मानकों पर निर्भर करता है, या तो नौकरी के लिए या प्रोग्रामर को बर्खास्त होने से बचने के लिए।

— बिल वुडगेर

Answer 12

अजगर (72 बाइट्स)

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

मुझे लगता है कि छोटे बना सकता है। सबसे पहले, फ़ाइल का नाम हार्डकोड करके (उपयोग करने के बजाय __file__)। लेकिन यहां, आप इस कोड को एक फ़ाइल में रख सकते हैं और इसे चला सकते हैं, जो भी इसका नाम है :)

Comments

आप शायद बदल सकते हैं &&करने के लिए &।

— होशो

कब से अनुमति है, user2509848?

— 1

खैर, आप

— व्हाट्सएप

चूंकि यह कोड-गोल्फ टैग नहीं किया गया है , मैं कोड को इस तरह

— रखूंगा

Answer 13

विंडोज टास्क समयबद्धक (.BAT)

विंडोज बैच स्क्रिप्ट। सभी चुनौतियों को पूरा करता है।

जहां तक ​​मैं देख सकता हूं कि यह अब तक का एकमात्र विंडोज समाधान है जो सभी आवश्यकताओं को पूरा करता है और इसमें कोई अमानवीय निर्भरता नहीं है (मेरा अन्य समाधान समान है लेकिन संकलन की आवश्यकता है)।

@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

कार्यक्रम मेरे C ++ / COM उत्तर के समान है ।

कार्यक्रम विंडोज टास्क शेड्यूलर के साथ एक बार के कार्य को शुरू करने और 60 सेकंड बाद में खुद को शुरू करने के लिए पंजीकृत करेगा (नियंत्रण कक्ष -> प्रशासनिक उपकरण -> कार्य शेड्यूलर को देखने के लिए, कार्य को "रीस्टोर" नाम दिया गया है)। यह कार्य करने से पहले आपको इसे मारने का मौका देने के लिए कार्यक्रम 5 सेकंड के लिए रुक जाएगा।

कमांड लाइन टास्क शेड्यूलर इंटरफ़ेस का उपयोग करता है schtasks.exe। स्क्रिप्ट में अंकगणित समय के मान्य और HH: MM प्रारूप में रखते हुए समय की गणना करने के लिए है।

चुनौती आवश्यकताएँ:

• खत्म होने पर खुद को फिर से शुरू करता है। हाँ। कार्यक्रम से बाहर निकलने से ठीक पहले टास्क निर्धारित है।

• एक ही समय में चल रहे कार्यक्रम का एक से अधिक उदाहरण नहीं। हाँ। कार्यक्रम पूरी तरह से बाहर निकलता है और ~ 60 सेकंड के लिए नहीं चलता है। यह शेड्यूलर द्वारा शुरू किया गया है।

• आप अपने चक्र के दौरान उपयोगकर्ता द्वारा मैन्युअल रूप से शुरू किए गए किसी भी उदाहरण को अनदेखा कर सकते हैं। हां, निरंतर कार्य नाम का उपयोग करने के साइड-इफेक्ट के रूप में।

• जब तक यह गारंटी है कि यह फिर से शुरू होता है। हाँ, बशर्ते टास्क शेड्यूलर चल रहा हो और schtasks.exe मौजूद हो (डिफ़ॉल्ट विंडोज कॉन्फ़िगरेशन में दोनों सही है)।

• चक्र को रोकने का एकमात्र तरीका प्रक्रिया को मारना है। हां, इस प्रक्रिया को चलाने के दौरान 5 सेकंड विंडो के दौरान मारा जा सकता है। कार्यक्रम 5 सेकंड की देरी से पहले कार्य को हटा देता है, इस समय इसे मारना शेड्यूलर में एक आवारा कार्य नहीं छोड़ेगा।

• आपके समाधान में पर्यावरण को पुनः आरंभ करना शामिल नहीं होना चाहिए हाँ।

नोट: सीमित कमांड लाइन इंटरफेस के कारण, पुनरारंभ समय को मिनटों में निर्दिष्ट किया जाना चाहिए और एसी एडाप्टर प्लग इन (खेद) के बिना लैपटॉप पर कार्य पुनरारंभ नहीं होगा ।

Answer 14

यूनिक्स खोल

मैंने अभी तक कई समाधान नहीं देखे हैं जो इसे फिर से शुरू करने के लिए एक असंबंधित कार्यक्रम पर भरोसा करते हैं। लेकिन यह वही है जो at(1)उपयोगिता के लिए बनाया गया था:

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

यह वास्तव में चल रहे कार्यक्रम को पकड़ना मुश्किल है, क्योंकि यह केवल प्रति मिनट एक बार चलता है और इतनी जल्दी बाहर निकलता है। सौभाग्य से atq(1)उपयोगिता आपको दिखाएगी कि यह अभी भी चल रहा है:

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

और atrm(1)आपको चक्र तोड़ने की अनुमति देगा:

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

आप के 1 minuteसाथ बदल सकते हैं 1 hour, या 1 week। या इसे 1461 daysएक कार्यक्रम दें जो हर 4 साल में एक बार चलता है।

Answer 15

शक्ति कोशिका

मैं गाली दे रहा हूं (और संभवतः तोड़ रहा हूं) मेरा अपना नियम।

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

खुद को पुनरारंभ करने के लिए अनंत समय लगता है।
यह मेजबान प्रक्रिया को मारकर मारा जा सकता है।

बस, इंतज़ार करो और देखो ;)

Comments

रचनात्मकता के लिए +1, लेकिन धोखा देने के लिए -1।

— जोहान्स एच।

हा, लेकिन क्या यह "गारंटी है कि यह फिर से शुरू होता है" अगर यह कभी नहीं रुकता है?

— जेसन सी

इसलिए मैंने कहा कि मैं शायद नियम तोड़ रहा हूं। यह अनंत की दार्शनिक सुंदरता है जिसे आप मान सकते हैं कि उसके बाद कुछ भी हो सकता है। ट्यूरिंग मशीन उस तरह से भी काम करती है।

— माइक्रोबियन

-100 क्योंकि मैं आपको अपनी खुद की प्रतियोगिता जीतने का समर्थन नहीं करता, विशेष रूप से एक तकनीकीता पर, लेकिन +101 क्योंकि इसे पुनः आरंभ करने के लिए इंतजार करना सबसे अच्छा शिथिलता बहाना है।

— जेसन सी

ठीक है, तुम्हें पता है, तो while true; do sleep 1; donequilify, है ना?

— यो '

Answer 16

दे घुमा के

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

इसे / निर्देशिका में repeat.sh के रूप में सहेजें और इसे निष्पादित अनुमति दें। यह फ़ाइल को हटाकर मारा जा सकता है

इसे 1 मिनट बाद चलाने के लिए क्रॉस्टेब में एक प्रविष्टि डालकर काम करता है।

Answer 17

विजुअल बेस 6 :)

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

चलाने के लिए, एक नया प्रोजेक्ट बनाएं, इस कोड के साथ एक मॉड्यूल जोड़ें, स्टार्ट-अप ऑब्जेक्ट को "सब मेन" पर सेट करें, संकलित करें, और फिर निष्पादन योग्य चलाएं।

---

अधिक पठनीय संस्करण:

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

Comments

VB6 एक असली आदमी का VB है। अपनी तरह का आखिरी!

— जेसन सी

Answer 18

HTML / JAVASCRIPT

HTML FILE a.html

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

Answer 19

दे घुमा के

लंबे समय से यह होना चाहिए, लेकिन मैं थक गया हूँ, और परवाह नहीं है :)

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

आपने कहा कि इसे पूरा करने के बाद इसे फिर से शुरू करना होगा, आपने विशेष रूप से यह नहीं कहा कि ऐसा बार-बार करना पड़ा, या अनिश्चित काल तक। इसके अलावा, आपने कहा था कि इसे कभी भी एक साथ चलाने के दो उदाहरण नहीं होने चाहिए ... यह कभी नहीं होगा। ;)

ऐसा करने के लिए किसी भी महान तरीके हैं। मेरा व्यक्तिगत पसंदीदा, कुछ ऐसा करना होगा जैसे पैकेट को कहीं दूर भेज दें, और फिर (किसी भी तरीके के माध्यम से), इस प्रक्रिया को प्रतिक्रिया दें।

Comments

तकनीकी रूप से, sleepप्रक्रिया समाप्त होने पर फिर से शुरू होती है

— pastebin.com 0mr8spkT

यदि प्रोग्राम एक ऐसा प्रोग्राम है जो इसे स्वयं को पुनरारंभ करता है , तो यह निहित है कि इसे अनिश्चित काल तक करना है - अन्यथा यह कुछ और फिर से शुरू कर रहा है जो स्वयं नहीं है।

— जेसन सी

@ जेसन सी: बहुत अधिक दार्शनिक होने के बिना, इस हद तक कि यह संभवतः कर सकता है, यह खुद को पुनरारंभ करता है। हम बहस कर सकते हैं कि इसे वास्तव में स्वयं को पुनः आरंभ करने के लिए कितना जटिल होना चाहिए , लेकिन मुझे लगता है कि लेखक का मतलब क्या है यह अच्छी तरह से परे है। हालाँकि, यदि आप चाहते हैं कि यह वास्तव में स्वयं को पुनः आरंभ करें, तो यह संभवतः कुछ ऐसा होगा जो गोटो, या JMP का उपयोग करता है, या जो कुछ भी आपकी भाषा का निर्माण कर सकता है, वह शुरू करने के लिए वापस जा सकता है, इसलिए यह स्वयं को "पुनरारंभ करना" है। अन्यथा, यह केवल कुछ ऐसा निष्पादित कर रहा है जो विशिष्ट रूप से स्वयं की तरह है। लेकिन तब कोई व्यक्ति संभवतः ऐसा मुद्दा उठाएगा कि वह फिर से शुरू न हो। तो मैं पचाता हूं।

— इयान विजार्ड

Answer 20

एंड्रॉयड: एक अलार्म 1 सेकंड के बाद गतिविधि को फिर से शुरू करेगा

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

}

Answer 21

C + MPI पर्यावरण

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

आपके पास ओपनएमपीआई या कुछ अन्य एमपीआई कार्यान्वयन स्थापित होना चाहिए। संकलन

mpicc -o mpifork mpifork.c

अब जब मैं इसके बारे में सोचता हूं, तो कोई कारण नहीं है कि आपके पास mpicc - gcc या जो भी संकलक काम करेगा, उसका उपयोग करना होगा। आपके पास सिर्फ mpirun होना चाहिए।

gcc -o mpifork mpifork.c

इसे चलाने के लिए, आपको संभवतः पूर्ण पथ नाम शामिल करना चाहिए, और मेजबानों की सूची शामिल करनी चाहिए। उदाहरण के लिए, मैंने कुछ प्रविष्टियाँ / etc / host में जोड़ीं, जो सभी ने लोकलहोस्ट को इंगित कीं, और इसे इस तरह चलाया:

/home/phil/mpifork localhost localhost1 localhost2 localhost3 localhost4

निष्पादन योग्य किसी भी मशीन पर उसी निर्देशिका में होना चाहिए जिसे आप इस पर चलाना चाहते हैं।

---

अनिवार्य रूप से, यह कमांड लाइन पर उपलब्ध कराए गए मेजबानों की एक सूची लेता है, एक मेजबान का चयन करता है, और एक ही तर्कों के साथ लक्ष्य होस्ट पर निष्पादन योग्य लॉन्च करता है। यदि सब कुछ पूरी तरह से चला जाता है, तो mpirun खुद को अलग-अलग मशीनों पर (या एक ही मशीन को कॉल करेगा, यदि आप केवल 'लोकलहोस्ट' प्रदान करते हैं। निष्पादन योग्य स्वयं (mpifork) समाप्त हो जाता है - कॉल करने के बाद execvp, यह अब पहली मशीन पर निष्पादित नहीं होता है।

यदि आप बुराई करना चाहते हैं, तो आप इसके बजाय प्रत्येक मशीन पर यह लॉन्च कर सकते हैं , जिसमें मेजबानों की पूरी सूची शामिल है जो कमांड लाइन पर प्रदान की गई है args। कि हर मशीन पर खुद की एक प्रति फिर से स्पॉन करेगी, एक ओवरबॉम्ब।

हालाँकि, इस रूप में, मुझे पूरा यकीन है कि यह नियमों को पूरा करता है।

Answer 22

जावास्क्रिप्ट

जब आवश्यक नहीं "नेटवर्क पर जा रहा है" बिना :-) जावास्क्रिप्ट के इवेंट लूप शेड्यूलिंग हमें ऐसे प्रोग्राम लिखने की अनुमति देता है जो दी गई आवश्यकताओं को बहुत आसानी से पूरा करते हैं:

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

यह program10 बार प्रति सेकंड की गति से फ़ंक्शन को "पुनरारंभ" करता है । यह जावास्क्रिप्ट की प्रकृति द्वारा गारंटीकृत है कि केवल एक ही कार्य एक ही समय में चल रहा होगा, और यह "पर्यावरण को पुनरारंभ नहीं करता" जैसा कि "पृष्ठ को फिर से लोड करें"।

Answer 23

x86 विधानसभा

पूरी तरह से यह सुनिश्चित नहीं है कि यह आपके मानदंडों को फिट करता है क्योंकि यह एक नई प्रक्रिया नहीं करता है, लेकिन यहां यह वैसे भी है।

कार्यक्रम एक संदेश बॉक्स दिखाएगा, कुछ मेमोरी आवंटित करेगा, आवंटित मेमोरी में अपने स्वयं के कोड अनुभाग की प्रतिलिपि बनाएँ, और फिर उस स्थान पर कूदें जो चक्र शुरू हो रहा है। यह तब तक चलना चाहिए जब तक कि मॉलॉक विफल न हो जाए।

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'

झल्लाहट के साथ संकलित।

Comments

चूंकि यह नए कॉपी किए गए कोड को कॉल करने के लिए आपके प्रोग्राम का हिस्सा है, इसलिए तकनीकी रूप से आपका प्रोग्राम कभी भी समाप्त नहीं हुआ है।

— माइक्रोबियन

निम्न स्तर के दृष्टिकोण से, यहाँ सभी कार्यक्रमों के बारे में कहा जा सकता है। :-)

— ब्रायन नोब्लुच

@BrianKnoblauch मैं असहमत हूं। यहां सबसे दिलचस्प जवाब सिस्टम वातावरण को संशोधित करने के लिए लगता है ताकि पहले एक के मारे जाने के कुछ समय बाद प्रक्रिया की एक नई प्रतिलिपि शुरू हो। उदाहरण के लिए, मुझे लगता है कि भविष्य में इस प्रक्रिया को चलाने के लिए एक क्रोन जॉब तैयार करना प्रक्रिया को पूरी तरह से मरने देने का एक अच्छा तरीका होगा, फिर से शुरू किया जाएगा।

— केविन - मोनिका

@BrianKnoblauch वास्तव में नहीं। एक प्रक्रिया एक ऑपरेटिंग सिस्टम कंस्ट्रक्शन है (जो इन दिनों - जैसे 1982 में 286 में संरक्षित मोड के आगमन के बाद से - वर्चुअल एड्रेस स्पेस और संरक्षित मेमोरी के माध्यम से हार्डवेयर द्वारा भी समर्थित है)। जब यह समाप्त होता है, तो वह सारी जानकारी चली जाती है। हालांकि यह स्पष्ट रूप से चुनौती में नहीं कहा गया था, मैं चुनौती की भावना का अर्थ यह लेता हूं कि "पुनरारंभ" का अर्थ है कि एक नई प्रक्रिया आईडी असाइन की गई है।

— जेसन सी

ठीक है, मैं +1 देता अगर आप रास्ते पर स्मृति को मुक्त करने में कामयाब रहे (कृपया मुझे @एक बार प्रबंधित करके देखें, क्योंकि मैं संभवतः इस पर अपनी नज़र नहीं रखूंगा)।

— यो '

Answer 24

लिनक्स अपस्टार्ट इनिट

प्रश्न के सख्त पढ़ने को देखते हुए, मुझे लगता है कि यह असंभव है। संक्षेप में, यह किसी अन्य चल रहे कार्यक्रमों की मदद से अनायास शुरू करने के लिए एक कार्यक्रम के लिए पूछ रहा है।

कुछ atऔर- chronआधारित उत्तर हैं, लेकिन सबसे सख्त पढ़ने के साथ, atdऔरanacron पूरक कार्यक्रम हैं जो हर समय चल रहे हैं, इसलिए वे अयोग्य हो सकते हैं।

एक संबंधित दृष्टिकोण, लेकिन लिनक्स के उपयोग के लिए थोड़ा निचला स्तर है init। रूट के रूप में, .conf फ़ाइल को इसमें जोड़ें/etc/init/ :

वर्णन "हमेशा के लिए"

रनलेवल पर शुरू करें [2345]
रनलेवल पर रुकें [2345]

respawn

नींद को क्रियान्वित करें

फिर initइसकी .conf फाइलें फिर से पढ़ें:

sudo telinit 5

यह एक sleepप्रक्रिया शुरू करेगा जो 10 सेकंड तक जीवित रहेगा, फिर बाहर निकल जाएगा। initइसके बाद sleepपिछले एक का पता लगाने के बाद वह दूर चला गया।

बेशक यह अभी भी initएक पूरक कार्यक्रम के रूप में उपयोग कर रहा है । आप तर्क दे सकते हैं कि initयह कर्नेल का एक तार्किक विस्तार है और हमेशा किसी भी लिनक्स में उपलब्ध होगा ।

यदि यह स्वीकार्य नहीं है, तो मुझे लगता है कि करने के लिए अगली निचले स्तर की चीज एक कर्नेल मॉड्यूल बनाने के लिए होगी जो एक यूजरस्पेस प्रक्रिया का जवाब देती है (यह निश्चित नहीं है कि यह कितना आसान है)। यहां यह तर्क दिया जा सकता है कि कर्नेल एक प्रक्रिया नहीं है, और इसलिए एक कार्यक्रम (पूरक) नहीं है। दूसरी ओर, कर्नेल सीपीयू के बिंदु से अपने आप में एक प्रोग्राम है।

Answer 25

TI-BASIC: 5 अक्षर

इसे कहते हैं prgmA

:prgmA

Comments

मैं 6 वर्णों की गिनती कर सकता हूं। क्या टीआई-बेसिक कार्यक्रम के आकार की गिनती के बारे में कुछ खास है?

— pastebin.com 0mr8spkT

:जब भी आप TI-बुनियादी में प्रोग्रामिंग कर रहे हैं लाइन प्रतीक का सिर्फ शुरुआत है। यह कुछ ऐसा नहीं है जिसे आप टाइप करते हैं, यह सिर्फ संपादक में है।

— scrblnrd3

मैं देखता हूं, जानकारी के लिए धन्यवाद

— pastebin.com स्लैश 0mr8spkT

पुनरावर्ती आह्वान नहीं है? Aआधार मामले के रूप में इसे बढ़ाने और उपयोग करने का प्रयास करें , आप देखेंगे कि यह अंततः बाहर निकल रहा है।

— ζ--

अच्छी तरह से सभी चर टी-बेसिक में ग्लोबल्स हैं, इसलिए मुझे यकीन नहीं है। यह हो सकता है

— scrblnrd3