ആശംസകൾ, വെബ്കോഡിയസ് ബ്ലോഗിന്റെ പ്രിയ വായനക്കാർ! അതിനാൽ, നമുക്ക് നേരിട്ട് കാര്യത്തിലേക്ക് കടക്കാം. ആദ്യം, ചോദ്യത്തിന്റെ രണ്ടാം ഭാഗത്തിന് ഞാൻ ഉത്തരം നൽകും: എന്തുകൊണ്ട് ഇത് ആവശ്യമായി വന്നേക്കാം? സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം അളക്കുക?.വെബ് പ്രോജക്ടുകൾ ഡീബഗ്ഗ് ചെയ്യുന്നതിൽ പ്രവർത്തിക്കുമ്പോൾ, സ്ക്രിപ്റ്റുകളുടെ എക്സിക്യൂഷൻ സമയമാണ് കണക്കിലെടുക്കേണ്ട ഒരു പ്രധാന ഘടകം. ഒരു പ്രത്യേക കോഡ് എത്ര വേഗത്തിലും കാര്യക്ഷമമായും പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ ഈ പരാമീറ്റർ ആവശ്യമാണ്. ഒരു PHP സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് സെർവർ ചെലവഴിച്ച സമയം നിർണ്ണയിക്കുന്നതിലൂടെ, കോഡ് ഒപ്റ്റിമൈസേഷൻ ആവശ്യമാണോ ഇല്ലയോ എന്ന് നിങ്ങൾക്ക് നിഗമനം ചെയ്യാം. അടുത്തതായി, ഇത് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം.

PHP സ്ക്രിപ്റ്റുകളുടെ പ്രകടനം വിശകലനം ചെയ്യുന്നതിന്, വിവിധ വിപുലീകരണങ്ങളും ലൈബ്രറികളും ഉണ്ട്, ഉദാഹരണത്തിന് XDebug, അവയ്ക്ക് സ്ക്രിപ്റ്റുകൾ ഡീബഗ് ചെയ്യാനും എക്സിക്യൂഷൻ സമയം അനുസരിച്ച് പ്രൊഫൈൽ ചെയ്യാനും കഴിയും. എന്നാൽ അത്തരം വിപുലീകരണങ്ങൾ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ അവ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും ക്രമീകരിക്കുന്നതിനും സമയം ചെലവഴിക്കേണ്ടതുണ്ട്. തീർച്ചയായും, സങ്കീർണ്ണമായ വാസ്തുവിദ്യ, ധാരാളം സ്ക്രിപ്റ്റുകൾ, ദശലക്ഷക്കണക്കിന് കോഡ് ലൈനുകൾ എന്നിവയുള്ള വലിയ പ്രോജക്റ്റുകളുടെ പ്രവർത്തനം ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിന്, അത്തരം വിപുലീകരണങ്ങൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്. എന്നാൽ നിങ്ങൾക്ക് 3-4 സ്ക്രിപ്റ്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്യേണ്ടതുണ്ടെങ്കിൽ, സ്ക്രിപ്റ്റിന്റെ പ്രവർത്തന സമയം അളക്കാൻ നിങ്ങൾക്ക് PHP ടൂളുകൾ മാത്രമേ ഉപയോഗിക്കാനാകൂ.

php-ൽ സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം എങ്ങനെ നിർണ്ണയിക്കും

01/01/1970 അർദ്ധരാത്രി മുതൽ കടന്നുപോയ സെക്കൻഡുകളുടെ എണ്ണം നൽകുന്ന ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷൻ മൈക്രോടൈം(), തീയതിയും സമയവും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് ഈ പ്രശ്‌നം എളുപ്പത്തിൽ പരിഹരിക്കാനാകും. ഈ ഫംഗ്‌ഷൻ രണ്ടുതവണ വിളിക്കുന്നതിലൂടെ, കോളുകൾക്കിടയിലുള്ള കഴിഞ്ഞ സമയം നമുക്ക് കണക്കാക്കാം:

നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, ഫലം ഇതുപോലെയായിരിക്കും:

സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം: 0.00059400000000001

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് ചുരുക്കത്തിൽ. മൈക്രോടൈം(ട്രൂ) ഫംഗ്‌ഷൻ ഉപയോഗിച്ച്, $start വേരിയബിളിൽ സ്‌ക്രിപ്റ്റ് പ്രവർത്തിക്കാൻ തുടങ്ങുമ്പോൾ ഞങ്ങൾ ടൈം സ്റ്റാമ്പ് സംഭരിക്കുന്നു. അടുത്തതായി ചില പ്രവർത്തനങ്ങൾ നടത്തുന്ന വർക്കിംഗ് കോഡ് വരുന്നു. ഈ ഉദാഹരണം usleep() ഫംഗ്‌ഷനെ വിളിക്കുന്നു, ഇത് ഒരു നിശ്ചിത എണ്ണം മൈക്രോസെക്കൻഡുകൾക്ക് സ്‌ക്രിപ്റ്റ് മന്ദഗതിയിലാക്കുന്നു. തുടർന്ന് നമുക്ക് സ്‌ക്രിപ്റ്റിന്റെ അവസാന സമയം ലഭിക്കും, അത് $end വേരിയബിളിൽ സംഭരിക്കുകയും $end എന്നതിൽ നിന്ന് $start കുറച്ചുകൊണ്ട് കോഡ് എക്‌സിക്യൂഷൻ സമയം കണക്കാക്കുകയും ചെയ്യുന്നു. തൽഫലമായി, ഞങ്ങൾക്ക് സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം ലഭിച്ചു.

എങ്ങനെ നിർണ്ണയിക്കണമെന്ന് ഇപ്പോൾ അറിയാം php സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം, നിങ്ങൾക്ക് കോഡിന്റെ വിവിധ ബ്ലോക്കുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ തുടങ്ങാം. നിങ്ങൾക്ക് ആശംസകൾ നേരുന്നു, അടുത്ത പോസ്റ്റുകളിൽ നിങ്ങളെ കാണാം!

സ്ക്രിപ്റ്റുകൾ ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ, ആദ്യം കണക്കിലെടുക്കേണ്ട ഒരു നിർബന്ധിത ഘടകം സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം. ഈ ചെറിയ ലേഖനത്തിൽ ഞാൻ വളരെ നല്ലതും ലളിതവുമായ ഒരു വഴി കാണിക്കും, ഒരു സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം എങ്ങനെ കണ്ടെത്താം.

തീയതിയും സമയവും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള ഫംഗ്ഷനുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഇത്. ഒരു ഉദാഹരണം നോക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു, അതുവഴി ഇത് എങ്ങനെ സംഭവിക്കുന്നു എന്ന് നിങ്ങൾക്ക് മനസ്സിലാകും സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം കണക്കാക്കുന്നു:

$ആരംഭിക്കുക = മൈക്രോടൈം(ശരി);
$സം = 0;
ഇതിനായി ($i = 0; $i< 100000; $i++) $sum += $i;
എക്കോ "സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം: ".(മൈക്രോടൈം(ട്രൂ) - $start);
?>

അതിന്റെ ഫലമായി നമ്മൾ അത് കാണും സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയംഉദാഹരണത്തിന്, ഇതുപോലെയായിരിക്കും: " 0.014652967453 ". നിങ്ങൾ അതിനെ ചുറ്റിപ്പറ്റിയാൽ, പിന്നെ ഇത് 0.015 സെക്കന്റുകൾ. ഇത് തിരക്കഥയുടെ നിർവ്വഹണ സമയമാണ്.

ഇപ്പോൾ ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് സംസാരിക്കാം. ഫംഗ്ഷൻ മൈക്രോടൈം()പാസ്സായ മൂല്യത്തോടൊപ്പം സത്യംഅർദ്ധരാത്രി മുതൽ സെക്കൻഡുകളുടെ എണ്ണം നൽകുന്നു 01.01.1970 , ഈ മൂല്യം സെക്കന്റിന്റെ നൂറിലൊന്നായി കണക്കാക്കുന്നു.

അടുത്തതായി ഞങ്ങൾ പരിശോധിക്കുന്ന സാധാരണ സ്ക്രിപ്റ്റ് വരുന്നു. പകരം, തീർച്ചയായും, നിങ്ങളുടെ സ്ക്രിപ്റ്റ് ഉണ്ടാകും. അവസാനമായി, അവസാന വരി നിലവിലെ സമയവും (സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷം) സ്ക്രിപ്റ്റ് ആരംഭിച്ചപ്പോൾ ഞങ്ങൾ റെക്കോർഡ് ചെയ്തതും തമ്മിലുള്ള വ്യത്യാസം കാണിക്കുന്നു. സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷമുള്ള സമയവും അത് പ്രവർത്തിക്കാൻ തുടങ്ങുന്നതിന് മുമ്പുള്ള സമയവും തമ്മിലുള്ള വ്യത്യാസം സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയം.

ഇത് ഇവിടെ ലളിതമാണെന്ന് ഞാൻ കരുതുന്നു. എന്നാൽ സമയം കണക്കാക്കുന്നതിനുള്ള ഈ രീതി ഉപയോഗിക്കണമെന്ന് ഞാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഈ സൈറ്റ് സ്ഥിതിചെയ്യുന്ന എന്റെ എഞ്ചിന്റെ ജോലി ഞാൻ ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ, ഞാൻ അതിന്റെ ജോലി ഏകദേശം ത്വരിതപ്പെടുത്തി 2 തവണ.

രചയിതാവിൽ നിന്ന്:എന്റെ സുഹൃത്തിന്റെ മകൻ രസതന്ത്രത്തിൽ വളരെയധികം താൽപ്പര്യം പ്രകടിപ്പിച്ചു, അവൻ വീട്ടിൽ വിവിധ "ടെസ്റ്റുകൾ" നടത്താൻ തുടങ്ങി. അടുക്കളയിലെ ചാൻഡിലിയർ അവരുടെ "ഇര" ആയിത്തീർന്നതിനുശേഷം, അവന്റെ മുൻഗണനകൾ മാറ്റാൻ പിതാവ് അവനോട് ആവശ്യപ്പെട്ടു. തൽഫലമായി, കുട്ടി സ്ഥിതിവിവരക്കണക്കുകളിൽ താൽപ്പര്യപ്പെടുകയും ഒരു മത്സരത്തിന്റെ ശരാശരി എരിയുന്ന സമയം കണക്കാക്കാൻ തീരുമാനിക്കുകയും ചെയ്തു. ഫലം മുഴുവൻ അപ്പാർട്ട്മെന്റിനും ഏതാണ്ട് തീപിടിച്ചു. പ്രോഗ്രാമിംഗ് ആരംഭിക്കാനും PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം സജ്ജമാക്കാനും ഞാൻ ശാസ്ത്രജ്ഞനെ ഉപദേശിച്ചു.

പ്രോഗ്രാമിംഗിലെ അളവുകൾ എന്തുകൊണ്ട്?

ഒന്നാമതായി, ഇത് രസതന്ത്രത്തേക്കാളും സ്ഥിതിവിവരക്കണക്കുകളേക്കാളും സുരക്ഷിതമാണ്. എന്നാൽ വാസ്തവത്തിൽ, പ്രോഗ്രാം കോഡിന്റെ എക്സിക്യൂഷൻ സമയം മുഴുവൻ റിസോഴ്സിന്റെയും അതിന്റെ വ്യക്തിഗത മൊഡ്യൂളുകളുടെയും പ്രകടനത്തെ ബാധിക്കുന്ന ഒരു പ്രധാന പാരാമീറ്ററാണ്. ഒപ്റ്റിമൈസേഷനും ടെസ്റ്റിംഗും സമയത്ത് ഈ പരാമീറ്റർ കൂടുതൽ ഡിമാൻഡാണ്.

നമുക്ക് അല്പം സങ്കൽപ്പിക്കാം. ഏതെങ്കിലും തരത്തിലുള്ള "വീട്ടിൽ എഴുതിയ" എഞ്ചിൻ ഉണ്ടെന്ന് നമുക്ക് സങ്കൽപ്പിക്കുക, അത് ഡവലപ്പർ ഒരു നല്ല ഹോസ്റ്റിംഗിലേക്ക് "അപ്ലോഡ്" ചെയ്യുകയും (അതിനെ അടിസ്ഥാനമാക്കി) തന്റെ വെബ്സൈറ്റ് സമാരംഭിക്കുകയും ചെയ്തു. എന്നാൽ ചില കാരണങ്ങളാൽ, ഉപയോക്തൃ ഭാഗത്ത് റിസോഴ്സ് ലോഡ് ചെയ്യുന്നത് വളരെ മന്ദഗതിയിലാണ്.

അത്തരമൊരു സാഹചര്യത്തിൽ, തുടക്കത്തിൽ എല്ലാ പാലുണ്ണികളും ഹോസ്റ്ററിൽ വീഴും. മിക്കവാറും, കോപാകുലനായ ഒരു പ്രോഗ്രാമർ ഹോസ്റ്റിംഗ് പിന്തുണാ സേവനത്തിൽ ഒരു പരാതി ഫയൽ ചെയ്യും. കരാറിന്റെ നിബന്ധനകൾ പാലിക്കപ്പെടുന്നില്ലെന്ന് അവർ പറയുന്നു, സൈറ്റ് കഷ്ടിച്ച് "ജീവനോടെ"...

എന്നാൽ വാസ്തവത്തിൽ, ഒരു ഡൈനാമിക് റിസോഴ്സിന്റെ സ്ലോ ലോഡിംഗ് പേജുകളുടെ പ്രശ്നം എഞ്ചിനിൽ തന്നെ മറഞ്ഞിരിക്കാം. പിന്നീട് ഒരു "ഡമ്മി" ആയി കാണപ്പെടാതിരിക്കാൻ, പരിചയസമ്പന്നനായ ഒരു ഡെവലപ്പർ ഒരു പ്രോജക്റ്റ് ഡെലിവർ ചെയ്യുന്നതിന് മുമ്പ് ഒരു PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം അളക്കുന്നു.

PHP സവിശേഷതകൾ

ഞാൻ എല്ലായ്പ്പോഴും അതിനെ ഏറ്റവും സൗകര്യപ്രദമായ പ്രോഗ്രാമിംഗ് ഭാഷകളിലൊന്ന് എന്ന് വിളിക്കുന്നു. കോഡിന്റെ പ്രവർത്തന സമയം ട്രാക്കുചെയ്യുന്നതിന്, സ്‌ക്രിപ്റ്റിന്റെ ഓരോ വരിയും തടസ്സപ്പെടുത്തുന്നതിന് ഡവലപ്പർ നീണ്ട "ടാൽമഡ്‌സ്" എഴുതേണ്ടതില്ല. ഈ സാങ്കേതികവിദ്യ നിരവധി പ്രത്യേക ഉപകരണങ്ങൾ നടപ്പിലാക്കുന്നു. മൈക്രോടൈം() ഫംഗ്‌ഷനാണ് പ്രധാനം. 1970-ന്റെ തുടക്കം മുതൽ കടന്നുപോയ സമയം (മില്ലിസെക്കൻഡിൽ) അത് തിരികെ നൽകുന്നു. "യുണിക്സ് യുഗത്തിന്റെ ആരംഭം" എന്ന് വിളിക്കപ്പെടുന്ന സമയം. നിങ്ങൾ get_as_float പാരാമീറ്റർ ട്രൂ മൂല്യമുള്ള ഫംഗ്‌ഷനിലേക്ക് കൈമാറുകയാണെങ്കിൽ, അത് സമയ കാലയളവ് മുഴുവൻ സെക്കൻഡുകളുടെയും ഫ്രാക്ഷണൽ മില്ലിസെക്കൻഡുകളുടെയും രൂപത്തിൽ തിരികെ നൽകും.

മൈക്രോടൈം() ഉപയോഗിക്കുന്നതിനുള്ള തത്വം ഇപ്രകാരമാണ്: സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിലും അതിന്റെ അവസാനത്തിലും ഫംഗ്ഷൻ വിളിക്കുന്നു. അപ്പോൾ പ്രാരംഭ മൂല്യം അവസാന മൂല്യത്തിൽ നിന്ന് കുറയ്ക്കുന്നു. ഒരു സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം എങ്ങനെ കണക്കാക്കാം എന്നത് ഇതാ:

"; $last=microtime(true); $value=$last-$first; echo "സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്തിരിക്കുന്നത്: ".$value; ?>

കോഡിന്റെ പ്രവർത്തന സമയം മാറ്റുന്നു

PHP-യിൽ, സ്‌ക്രിപ്റ്റ് റണ്ണിംഗ് ടൈം മൂല്യം പ്രോഗ്രമാറ്റിക്കായി പരിമിതപ്പെടുത്താം (കുറയ്ക്കുകയോ കൂട്ടുകയോ). ഇത് ചെയ്യുന്നതിന്, നിരവധി ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു, അവയിൽ ഓരോന്നും കോൺഫിഗറേഷൻ ഫയലിൽ (php.ini) സജ്ജമാക്കിയ ഒരു പാരാമീറ്റർ പുനരാലേഖനം ചെയ്യുന്നു.
ആദ്യം, നമുക്ക് നമ്മുടെ കോഡ് പരിഷ്‌ക്കരിച്ച് ലൂപ്പ് ആവർത്തനങ്ങളുടെ എണ്ണം 20 മടങ്ങ് 200 ദശലക്ഷമായി വർദ്ധിപ്പിക്കാം. എല്ലാം ശരിയാണെങ്കിൽ, സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ചതിന് ശേഷം നിങ്ങൾക്ക് ഒരു മാരകമായ പിശക് സന്ദേശം ലഭിക്കും.

ഇതിനർത്ഥം ക്രമീകരണങ്ങളിൽ max_execution_time പാരാമീറ്റർ സ്ഥിരസ്ഥിതി മൂല്യത്തിലേക്ക് (30 സെക്കൻഡ്) സജ്ജീകരിച്ചിരിക്കുന്നു എന്നാണ്. PHP-യിൽ ഒരു സ്ക്രിപ്റ്റിന്റെ പരമാവധി എക്സിക്യൂഷൻ സമയം 3 മടങ്ങ് വർദ്ധിപ്പിക്കാം.

ഇപ്പോൾ ഞങ്ങൾക്ക് പിശക് സന്ദേശങ്ങളൊന്നും ലഭിക്കുന്നില്ല.

ക്രോണ്ടാബ് ഇല്ലാതെ പിഎച്ച്പിയിൽ ഒരു സ്ക്രിപ്റ്റിന്റെ പശ്ചാത്തല നിർവ്വഹണം

• വെബ്സൈറ്റ് വികസനം

PHP-യിൽ ഒരു ഡെമൺ എഴുതാൻ ഞാൻ അമ്പരന്നു. ആ. ക്രമരഹിതമായ സമയത്ത് (എല്ലായ്‌പ്പോഴും ക്രമരഹിതമായി) നിശ്ചിത എണ്ണം മണിക്കൂറിൽ നിശ്ചിത പ്രാവശ്യം ചില പ്രവർത്തനങ്ങൾ നിർവഹിക്കുന്ന ഒരു സ്‌ക്രിപ്റ്റ്, ക്രോൺ ഉപയോഗിക്കാതെ തന്നെ.

ഞാൻ മുമ്പൊരിക്കലും ശല്യപ്പെടുത്തിയിട്ടില്ല, പക്ഷേ ടാസ്‌ക് സജ്ജീകരിച്ച ശേഷം, ഇത് അസാധ്യമാണെന്ന് ഞാൻ ചിന്തിക്കാൻ തുടങ്ങി, PHP സ്ക്രിപ്റ്റ് ബ്രൗസർ വിളിക്കണം ... നന്നായി, ടാസ്‌ക് സജ്ജമാക്കി, അത് പൂർത്തിയാക്കേണ്ടതുണ്ട്.

സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂഷൻ സമയപരിധി പ്രവർത്തനരഹിതമാക്കുക എന്നതാണ് ആദ്യത്തെ ചിന്ത. ഹോസ്റ്റ് നിരോധിച്ചിരിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് അജാക്സ് അഭ്യർത്ഥന ഇടയ്ക്കിടെ ആവർത്തിക്കുക എന്നതാണ് രണ്ടാമത്തെ ആശയം (അതെ, സെക്കൻഡിൽ ഒരിക്കലെങ്കിലും). - സാധ്യമല്ല (ഉപഭോക്തൃ ആവശ്യകത).

വാസ്തവത്തിൽ, ബ്രൗസർ തുറക്കരുത്, ക്രോൺ ഉപയോഗിക്കരുത്, കൂടാതെ സ്ക്രിപ്റ്റ് ഉപയോക്താവിനെ പരിഗണിക്കാതെ അനിശ്ചിതമായി പ്രവർത്തിക്കണം. സ്വാഭാവികമായും, ഇത് കുറഞ്ഞത് സിസ്റ്റം ലോഡ് ചെയ്യണം.

1. ഒരു പായ്ക്ക് സിഗരറ്റ്, രാത്രി, ഗൂഗിൾ, പ്രമാണങ്ങൾ, പുസ്തകങ്ങൾ, മാനുവലുകൾ....
പോയി 1…

ഔട്ട്പുട്ടിൽ എനിക്ക് ലഭിക്കുന്നത്:
ടാസ്ക്_1:
നിർദ്ദിഷ്‌ട സമയങ്ങളുടെയും മണിക്കൂറുകളുടെയും അടിസ്ഥാനത്തിൽ ഒരു സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂഷൻ ടൈം ജനറേറ്റർ നടപ്പിലാക്കുക. ഈ സമയങ്ങൾ എവിടെയെങ്കിലും സൂക്ഷിക്കുക.

ടാസ്ക്_2:
ബ്രൗസർ അടച്ചതിനുശേഷം പ്രവർത്തിക്കുക

ടാസ്ക്_3:
സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയപരിധി അവസാനിച്ചതിന് ശേഷം ക്രാഷ് ചെയ്യരുത്

ടാസ്ക്_4:
ശരിയായ സമയത്ത് ചില പ്രവർത്തനങ്ങൾ ചെയ്യുക.

അങ്ങനെ…
കോൺഫിഗറേഷനിൽ ഞങ്ങൾ പ്രാരംഭ ഡാറ്റ എഴുതുന്നു:

Session_start(); // സെഷൻ ആരംഭിക്കുക $num_starts = 120; // സ്ക്രിപ്റ്റിന്റെ എണ്ണം ഒരു കാലയളവിൽ $hours = 1; // സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കേണ്ട മണിക്കൂറുകളുടെ എണ്ണം $num_starts തവണ. $time_sec = $ മണിക്കൂർ*3600; // ലോഞ്ച് സൈക്കിളിലെ സെക്കൻഡുകളുടെ എണ്ണം $time_to_start = അറേ(); // യഥാർത്ഥത്തിൽ, ലോഞ്ച് ടൈമുകളുള്ള ഒരു അറേignign_user_abort(1); // ബ്രൗസറുമായുള്ള കണക്ഷൻ നഷ്ടം അവഗണിക്കുക

അടുത്തതായി, സ്റ്റാർട്ടപ്പ് സമയം സൃഷ്ടിക്കാൻ ഞങ്ങളെ സഹായിക്കുന്ന ഒരു ഫംഗ്ഷൻ ഞങ്ങൾ എഴുതുന്നു.
അതിൽ നമ്മൾ 0 മുതൽ യഥാർത്ഥ ഇടവേളയിലെ സെക്കൻഡുകളുടെ എണ്ണം വരെയുള്ള ഒരു ക്രമരഹിത സംഖ്യ സൃഷ്ടിക്കുന്നു.
/****** * @desc ലോഞ്ചുകൾക്കിടയിലുള്ള ഇടവേള സൃഷ്ടിക്കുക. */ ഫംഗ്‌ഷൻ add_time2start() ( ആഗോള $time_sec, $time_to_start; $new_time = time()+rand(0, $time_sec); എങ്കിൽ (!in_array($new_time, $time_to_start)) ( // അങ്ങനെയൊരു സമയം ഇല്ലെങ്കിൽ അറേയിൽ - $time_to_start = $new_time; ) ചേർക്കുക ( add_time2start(); // അത്തരം സമയം ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് വീണ്ടും സൃഷ്ടിക്കുക. )

$k = 1; എങ്കിൽ ($_SESSION["num_st"] == "" || $_SESSION["num_st"][$num_starts-1]< time()) { // проверка, что в сессию не записаны данные и что эти данные не устарели. do { add_time2start($k); $k++; } while ($k < = $num_starts); sort($time_to_start, SORT_NUMERIC); $_SESSION["num_st"] = $time_to_start; }

സെർവർ സജ്ജമാക്കിയ പരമാവധി എക്‌സിക്യൂഷൻ സമയം പരിഗണിക്കാതെ, ഇപ്പോൾ നമുക്ക് സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്.
തത്വം ഇതാണ്:
1) സ്ക്രിപ്റ്റിന്റെ ആരംഭ സമയം നിർണ്ണയിക്കുക;
2) എക്സിക്യൂഷൻ സമയത്തിന്റെ സ്ഥാപിത പരിധി നിശ്ചയിക്കുക.
3) ഞങ്ങൾ ഒരു ലൂപ്പ് ആരംഭിക്കുന്നു, അതിനുള്ളിൽ ഞങ്ങൾ നിലവിലെ സമയം കണക്കാക്കുകയും സ്ക്രിപ്റ്റിന്റെ മൊത്തം പ്രവർത്തന സമയം കണക്കാക്കുകയും ചെയ്യുന്നു, വിക്ഷേപണ സമയങ്ങളുടെ ശ്രേണിയിലെ മൂല്യങ്ങൾ ഉപയോഗിച്ച് നിലവിലെ സമയം പരിശോധിക്കുക, ഒരു പൊരുത്തമുണ്ടെങ്കിൽ, ഞങ്ങൾ പ്രകടനം നടത്തുന്നു നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങൾ (എനിക്ക് exec.php ഫയലിൽ ഉണ്ട്). ഫയലുകൾ പ്രവർത്തിപ്പിക്കാൻ ഞങ്ങൾ സോക്കറ്റുകൾ ഉപയോഗിക്കുന്നു.
4) സ്ക്രിപ്റ്റ് റണ്ണിംഗ് സമയം അനുവദനീയമായ പരമാവധി അടുക്കുന്നത് വരെ സൈക്കിൾ ആവർത്തിക്കുക. പരമാവധി സമയം വരെ 5 സെക്കൻഡ് ശേഷിക്കുന്നത് വരെ ഞാൻ അത് സജ്ജമാക്കി.

അതിനാൽ... ഞങ്ങൾ പ്രാരംഭ സമയ ഡാറ്റ കണക്കാക്കുന്നു:

$start_time = microtime(); // സ്ക്രിപ്റ്റ് ലോഞ്ച് സമയം കണ്ടെത്തുക $start_array = പൊട്ടിത്തെറിക്കുക(" ",$start_time); // സെക്കൻറുകളും മില്ലിസെക്കൻഡുകളും വേർതിരിക്കുക $start_time = $start_array; // സ്ക്രിപ്റ്റിന്റെ ആരംഭ സമയം നേടുക $max_exec = ini_get("max_execution_time"); //സ്ക്രിപ്റ്റിന്റെ പരമാവധി പ്രവർത്തന സമയം നേടുക
യഥാർത്ഥത്തിൽ, ഒരു ചക്രം. കോഡിലെ അഭിപ്രായങ്ങൾ.

ചെയ്യുക( $nowtime = time(); // നിലവിലെ സമയം //// നിലവിലെ സമയം സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയങ്ങളുള്ള അറേയിലാണെങ്കിൽ...... എങ്കിൽ (in_array($nowtime, $_SESSION["num_st"]) ) (// $http = fsockopen("test.ru",80) പ്രവർത്തനങ്ങളുടെ പ്രധാന ഉള്ളടക്കം ഉപയോഗിച്ച് ഞങ്ങൾ സോക്കറ്റിനെ ഫയലിലേക്ക് ബന്ധിപ്പിക്കുന്നു; /// അതേ സമയം ഞങ്ങൾ അതിലേക്ക് സെഷൻ ഡാറ്റയും സമയവും കൈമാറുന്നു ഇത് fputs പ്രവർത്തിക്കണം($http, "GET http://test .ru/exec.php?".session_name()."=".session_id()."&nowtime=$nowtime HTTP/1.0\r\n") ; fputs($http, "Host: test.ru\r\ n"); fputs($http, "\r\n"); fclose($http); ) //// നിർദ്ദിഷ്ട പ്രവർത്തനം നടത്തി // കണ്ടെത്തുക ലൂപ്പ് തുടരണോ അതോ പുനരാരംഭിക്കണോ അതോ $now_time = മൈക്രോടൈം( exec_time = $now_time - $start_time+$exec_time; /// ഒരു സെക്കന്റ് ഉസ്ലീപ്പിനായി വേഗത കുറയ്ക്കുക(1000000); //പശ്ചാത്തലത്തിൽ പ്രവർത്തിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് നിർത്തുന്നു. എനിക്ക് മറ്റൊരു വഴിയും ആലോചിക്കാൻ കഴിഞ്ഞില്ല. എങ്കിൽ (file_exist("stop. txt")) പുറത്തുകടക്കുക; //സ്ക്രിപ്റ്റ് അവസാനിക്കാൻ 5 സെക്കൻഡിൽ താഴെ മാത്രമേ അവശേഷിക്കുന്നുള്ളൂവെങ്കിൽ, റണ്ണിംഗ് സമയം പരിശോധിക്കുക //ലൂപ്പ് അവസാനിപ്പിക്കുക . ) സമയത്ത്($exec_time< ($max_exec - 5));

ശരി, അനുവദനീയമായ സമയം അവസാനിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ സൈക്കിൾ പൂർത്തിയാക്കുകയും അതേ സ്ക്രിപ്റ്റ് മറ്റ് പ്രക്രിയകളിൽ സുരക്ഷിതമായി സമാരംഭിക്കുകയും ചെയ്യും (ഞങ്ങൾ തീർച്ചയായും ഇത് 5 സെക്കൻഡിനുള്ളിൽ സൂക്ഷിക്കും)

// അതേ സ്ക്രിപ്റ്റ് ഒരു പുതിയ പ്രക്രിയയായി സമാരംഭിക്കുകയും നിലവിലുള്ളത് അവസാനിപ്പിക്കുകയും ചെയ്യുക $http = fsockopen("test.ru",80); fputs($http, "GET http://test.ru/index.php?".session_name()."=".session_id()."&bu=$max_exec HTTP/1.0\r\n"); fputs($http, "ഹോസ്റ്റ്: test.ru\r\n"); fputs($http, "\r\n"); fclose($http);

എല്ലാം എഴുതി തീർന്നപ്പോൾ, ഉപയോഗപ്രദമായ ആപ്ലിക്കേഷൻ എന്നെ ആശയക്കുഴപ്പത്തിലാക്കി... നിങ്ങൾക്കത് ഒരു സേവനമായി ഉപയോഗിക്കാം. ഇതിന് നെറ്റ്‌വർക്കിൽ എന്തെങ്കിലും നിരീക്ഷിക്കാനും നിങ്ങളെ അറിയിക്കാനും കഴിയും, ഉദാഹരണത്തിന്, മെയിൽ വഴി. പിന്നെ ക്രോൺ ഒന്നും വേണ്ട.

സ്ക്രിപ്റ്റ് ഇപ്പോഴും ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും - ഞാൻ പരിഷ്ക്കരണങ്ങളൊന്നും ചെയ്തിട്ടില്ല.
വഴിയിൽ, എനിക്ക് എന്നെത്തന്നെ കീറിമുറിക്കാൻ കഴിയാത്തത് ഇതാ - തുടക്കത്തിൽ സ്ക്രിപ്റ്റ് സമാരംഭിക്കുന്നതിന് നിങ്ങൾ ഇപ്പോഴും ബ്രൗസർ തുറക്കേണ്ടതുണ്ട്.

നല്ല ദിവസം, സഹപ്രവർത്തകർ! 🙂

ഒരു PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയവും അതിന്റെ നിർവചനവും പോലുള്ള ഒരു വിഷയത്തിൽ സ്പർശിക്കാൻ ഇന്ന് ഞാൻ തീരുമാനിച്ചു.

ഈ ആവശ്യം എല്ലാ ദിവസവും ഉയർന്നുവരുമെന്ന് ഞാൻ പറയില്ല, എന്നാൽ കാലാകാലങ്ങളിൽ നിങ്ങൾക്ക് ഒരു PHP സ്ക്രിപ്റ്റിന്റെ പ്രവർത്തന സമയം ലഭിക്കുമ്പോൾ പ്രായോഗിക സാഹചര്യങ്ങൾ ഉണ്ടാകുന്നു.

PHP സ്‌ക്രിപ്‌റ്റിന്റെ എക്‌സിക്യൂഷൻ സമയം അന്തിമ ഓപ്ഷൻ തിരഞ്ഞെടുക്കുന്നതിനുള്ള പ്രധാന ഘടകമായിരിക്കുമ്പോൾ, കോഡ് റീഫാക്‌ടർ ചെയ്യുമ്പോഴും നിലവിലുള്ള അൽഗോരിതം ഒപ്റ്റിമൈസ് ചെയ്യുമ്പോഴും ഡെവലപ്പർമാരെ ഇത് ചെയ്യുന്നത് നിങ്ങൾക്ക് പിടിക്കാം.

കോഡിലെ ഒരു പ്രത്യേക പ്രവർത്തനത്തിന് എത്ര സമയമെടുക്കുമെന്ന് കണ്ടെത്താൻ ആഗ്രഹിക്കുന്ന മാനേജർമാർക്കും ഉപഭോക്താക്കൾക്കും ചിലപ്പോൾ ഈ നമ്പറുകൾ ആവശ്യമാണ്.

അതിനാൽ, ഈ ചെറിയ കുറിപ്പ് എഴുതാൻ ഞാൻ തീരുമാനിച്ചു, അതിൽ സമാനമായ ഒരു സാഹചര്യത്തിൽ നടപടിയെടുക്കുന്നതിനുള്ള നടപടിക്രമം രൂപപ്പെടുത്താൻ ഞാൻ തീരുമാനിച്ചു.

ആദ്യം, ഒരു PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം നിർണ്ണയിക്കുന്നതിനുള്ള അൽഗോരിതം തന്നെ നോക്കും, തുടർന്ന് അത് നടപ്പിലാക്കുന്ന കോഡ് ഞാൻ നൽകും.

ഒരു PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം - ഡിറ്റർമിനേഷൻ അൽഗോരിതം

ഞങ്ങളുടെ പ്രവർത്തനങ്ങളുടെ നടപടിക്രമം വളരെ ലളിതമായിരിക്കും:

1. സ്ക്രിപ്റ്റിൽ വ്യക്തമാക്കിയ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന് മുമ്പ് PHP കോഡിലെ നിലവിലെ സെർവർ സമയം നിർണ്ണയിക്കുക;
2. സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, ഞങ്ങൾ വീണ്ടും സെർവർ സമയം കണ്ടെത്തുന്നു;
3. PHP ഉപയോഗിച്ച്, സ്ക്രിപ്റ്റിന്റെ പൂർത്തീകരണവും അതിന്റെ ആരംഭവും തമ്മിലുള്ള സമയ വ്യത്യാസം ഞങ്ങൾ കണക്കാക്കുന്നു.

തത്ഫലമായുണ്ടാകുന്ന മൂല്യം PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയമായിരിക്കും, അത് കൂടുതൽ ഒപ്റ്റിമൈസേഷനും മറ്റ് പ്രവർത്തനങ്ങളും കണക്കിലെടുക്കാം.

PHP സ്ക്രിപ്റ്റ് റണ്ണിംഗ് ടൈം - അൽഗോരിതം നടപ്പിലാക്കൽ

PHP കോഡിൽ നിലവിലെ സമയം പ്രദർശിപ്പിക്കുന്നതിന്, സാധാരണ PHP ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ ഞാൻ തീരുമാനിച്ചു മൈക്രോടൈം(), ഇത് യുണിക്സ് ഫോർമാറ്റിൽ മൈക്രോസെക്കൻഡ് ഉപയോഗിച്ച് നിലവിലെ ടൈംസ്റ്റാമ്പ് നൽകുന്നു.

എന്തുകൊണ്ടാണ് ഇത്രയും കൃത്യത?

പിന്നെ, സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയത്തിലെ ചെറിയ മാറ്റങ്ങൾ പിടിക്കാൻ, കാരണം വലിയ തോതിൽ സ്ലോ കോഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ ചിലപ്പോൾ ഒരു സ്പ്ലിറ്റ് സെക്കൻഡ് മാരകമാകുകയും വലിയ നഷ്ടമുണ്ടാക്കുകയും ചെയ്യും.

നന്നായി, കൂടാതെ, കണക്കുകൂട്ടലുകളിൽ മൈക്രോസെക്കൻഡുകൾ കണക്കിലെടുക്കുന്നത് പോസിറ്റീവ് ദിശയിലുള്ള കണക്കുകൂട്ടലുകളുടെ കൃത്യതയെ ബാധിക്കുന്നു.

എന്റെ സൈദ്ധാന്തിക കഥകൾ പ്രദർശിപ്പിക്കുന്നതിന്, 30,000,000 ആവർത്തനങ്ങളുള്ള ഒരു ശൂന്യമായ ലൂപ്പിന്റെ പ്രവർത്തന സമയം കണക്കാക്കുന്ന ഒരു ലളിതമായ സ്ക്രിപ്റ്റ് ഞാൻ എഴുതി (വ്യക്തതയ്ക്കായി കൂടുതൽ എടുക്കാൻ ഞാൻ തീരുമാനിച്ചു):

PHP മൈക്രോടൈം() ഫംഗ്‌ഷന് ഒരു പാരാമീറ്റർ മാത്രമേയുള്ളൂ ഫ്ലോട്ട്_ആയി_ലഭിക്കുക, മൂല്യങ്ങൾ വ്യക്തമാക്കുമ്പോൾ സത്യംയുണിക്സ് യുഗം മുതൽ മൈക്രോസെക്കൻഡ് കൃത്യതയോടെ നിങ്ങൾക്ക് നിലവിലെ PHP സമയം സെക്കൻഡുകൾക്കുള്ളിൽ ലഭിക്കും.

എനിക്ക് നിലവിലെ സമയം ആവശ്യമായതിനാൽ, യുണിക്സ് യുഗത്തിന്റെ ആരംഭം മുതൽ സെക്കൻഡുകളുടെ എണ്ണമല്ല, ഞാൻ ഈ പാരാമീറ്റർ ഉപയോഗിച്ചു, അത് എന്റെ കോഡിൽ കാണാൻ കഴിയും.

ഫലമായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു പ്രതിധ്വനി(), ഇനിപ്പറയുന്ന സന്ദേശം സ്ക്രീനിൽ പ്രദർശിപ്പിച്ചു: സ്ക്രിപ്റ്റ് 1.3156361579895 സെക്കൻഡിൽ എക്സിക്യൂട്ട് ചെയ്തു.

ഈ സാങ്കേതികവിദ്യ ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് നിർണ്ണയിക്കാൻ, ഫംഗ്ഷൻ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റിനായി ഒരു നിശ്ചിത എക്സിക്യൂഷൻ സമയം സജ്ജീകരിക്കാൻ ഞാൻ തീരുമാനിച്ചു. ഉറക്കം(), ഇത് സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂഷൻ നിർദ്ദിഷ്‌ട സെക്കന്റുകളോളം വൈകിപ്പിക്കുന്നു.

തൽഫലമായി, ഇനിപ്പറയുന്ന നിർമ്മാണം സന്ദേശം നൽകി സ്ക്രിപ്റ്റ് 2.0000510215759 സെക്കൻഡിൽ എക്സിക്യൂട്ട് ചെയ്തു:

സെർവർ ഹാർഡ്‌വെയർ ഉപയോഗിച്ച് കോഡ് ഘടനകളെ വിളിക്കുകയും അവയുടെ നിർവ്വഹണ ഫലങ്ങൾ പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്ന സമയമാണ് സെക്കൻഡുകളുടെ സൂക്ഷ്മ ഭിന്നസംഖ്യകളാൽ നിർദ്ദിഷ്ട കാലതാമസം കവിയുന്നത്, അതിനാൽ നിങ്ങൾക്ക് അവയിലേക്ക് പൂർണ്ണമായും കണ്ണടയ്ക്കാനാകും.

അവർ ഇപ്പോഴും നിങ്ങളെയോ നിങ്ങളുടെ ഉപഭോക്താവിനെയോ പ്രകോപിപ്പിക്കുകയാണെങ്കിൽ, PHP ഫംഗ്‌ഷൻ റൗണ്ട്() ഉപയോഗിച്ച്, ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിച്ച് നിങ്ങൾക്ക് നിസ്സാരമായ റൗണ്ടിംഗിന്റെ രൂപത്തിൽ നൂറിലോ ആയിരത്തിലോ ഒരു ഹാക്ക് ഉപയോഗിക്കാം:

റൗണ്ട്(മൈക്രോടൈം(ശരി) - $ആരംഭം, 2);

മേൽപ്പറഞ്ഞ ഉദാഹരണത്തിനായി ഈ കോഡ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലം ഒരു വൃത്തിയുള്ള 2 സെക്കൻഡിന്റെ മൂല്യമായിരിക്കും, അത് ഏറ്റവും സങ്കീർണ്ണമായ പെർഫെക്ഷനിസ്റ്റുകൾക്ക് അനുയോജ്യമാകും :)

ഒരു PHP സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ സമയം എങ്ങനെ നിർണ്ണയിക്കും എന്നതിനെക്കുറിച്ചുള്ള ഇന്നത്തെ വിവരങ്ങൾ ഇത് അവസാനിപ്പിക്കുന്നു.

അഭിപ്രായങ്ങളിൽ നിങ്ങളുടെ ഫീഡ്‌ബാക്ക് എഴുതുക, സോഷ്യൽ നെറ്റ്‌വർക്കുകളിലെ പ്രോജക്റ്റിന്റെ പൊതു പേജുകളിൽ നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ചോദ്യങ്ങൾ ചോദിക്കുക.