задача

Используя любой тип распараллеливания, подождите несколько периодов, чтобы общее время сна составляло не менее минуты (но не более полутора минут).

Программа / функция должна завершиться в течение 10 секунд и вернуть (любым способом и в любом формате) два значения: общее истекшее время и общее выполненное время ожидания. Оба значения времени должны иметь точность не менее 0,1 секунды.

Это похоже на концепцию человеко-часов : работа, которая занимает 60 часов, может быть выполнена всего за 6 часов, если 10 работников разделят работу. Здесь у нас может быть 60 секунд времени ожидания, например, в 10 параллельных потоках, поэтому для завершения всей работы потребуется всего 6 секунд.

пример

Программа MyProgram создает 14 потоков, каждый поток спит 5 секунд:

MyProgram → [5.016,70.105]

Время выполнения превышает 5 секунд, а общее время ожидания превышает 70 секунд из-за служебной нагрузки.

Dyalog APL, 65 27 23 21 байт

(⌈/,+/)⎕TSYNC⎕DL&¨9/7

То есть:

      (⌈/,+/)⎕TSYNC⎕DL&¨9/7
7.022 63.162

Объяснение:

• ⎕DL&¨9/7: раскрутить 9 потоков, каждый из которых ждет 7 секунд. ⎕DLвозвращает фактическое количество времени, потраченное на ожидание, в секундах, которое будет таким же, как его аргумент дает или принимает несколько миллисекунд.
• ⎕TSYNC: дождитесь завершения всех потоков и получите результат для каждого потока.
• (⌈/,+/): возвращает самое длинное время выполнения одного отдельного потока (во время выполнения которого все другие потоки закончили, так что это фактическое время выполнения), за которым следует сумма времени выполнения всех потоков.

Попробуйте онлайн!

Python 2, 172 байта

import threading as H,time as T
m=T.time
z=H.Thread
s=m()
r=[]
def f():n=m();T.sleep(9);f.t+=m()-n
f.t=0
exec"r+=[z(None,f)];r[-1].start();"*8
map(z.join,r)
print m()-s,f.t

Это требует операционной системы с точностью времени более 1 секунды для правильной работы (другими словами, любой современной ОС). Создается 8 потоков, каждый из которых спит по 9 секунд, в результате чего время выполнения в реальном времени составляет ~ 9 секунд, а время параллельной работы ~ 72 секунды.

Хотя в официальной документации сказано, что Threadконструктор должен вызываться с помощью аргументов с ключевыми словами, я все же осторожен и в любом случае использую позиционные аргументы. Первый аргумент ( group) должен быть None, а второй аргумент является целевой функцией.

nneonneo указал в комментариях, что доступ к атрибуту (например, f.t) короче, чем доступ по индексу списка (например t[0]). К сожалению, в большинстве случаев несколько байтов, полученных в результате этого, будут потеряны из-за необходимости создания объекта, который позволяет создавать пользовательские атрибуты во время выполнения. К счастью, функции поддерживают пользовательские атрибуты во время выполнения, поэтому я использую это, сохраняя общее время в tатрибуте f.

Попробуйте онлайн

Спасибо DenkerAffe за трюк -5 байтов exec.

Спасибо kundor за -7 байт, указав, что аргумент потока не нужен.

Спасибо nneonneo за -7 байтов от разных улучшений.

Утилиты Bash + GNU, 85

\time -f%e bash -c 'for i in {1..8};{ \time -aoj -f%e sleep 8&};wait'
paste -sd+ j|bc

Принудительное использование timeисполняемого файла вместо встроенной оболочки путем добавления префикса к \.

Добавляется в файл j, который должен быть пустым или отсутствовать в начале.

Go - 189 байт

Спасибо @cat!

package main
import(."fmt";."time");var m,t=60001,make(chan int,m);func main(){s:=Now();for i:=0;i<m;i++{go func(){Sleep(Millisecond);t<-0}()};c:=0;for i:=0;i<m;i++{c++};Print(Since(s),c)}

Выходы (мс): 160,9939 мс , 60001 (160 мс для ожидания 60,001 с)

Баш 196 117 114 93 байта

Обновлен для поддержки большей точности времени благодаря интеграции предложений от @manatwork и @Digital Trauma, а также нескольких других оптимизаций пространства:

d()(date +$1%s.%N;)
b=`d`
for i in {1..8};{ (d -;sleep 8;d +)>>j&}
wait
bc<<<`d`-$b
bc<<<`<j`

Обратите внимание, что это предполагает, что jфайл отсутствует в начале.

JavaScript (ES6), 148 байт

with(performance)Promise.all([...Array(9)].map(_=>new Promise(r=>setTimeout(_=>r(t+=now()),7e3,t-=now())),t=0,n=now())).then(_=>alert([now()-n,t]));

Обещает ждать 9 раз в течение 7 секунд в общей сложности 63 секунды (на самом деле 63,43, когда я пытаюсь), но на самом деле, когда я пытаюсь, только 7,05 секунды реального времени.

C, 127 байт (вращается процессор)

Это решение вращает процессор вместо сна и подсчитывает время с помощью timesфункции POSIX (которая измеряет время процессора, потребляемое родительским процессом и всеми ожидаемыми дочерними процессами).

Он запускает 7 процессов, которые вращаются по 9 секунд каждый, и выводит окончательное время в C часах (в большинстве систем 100 тактов = 1 секунда).

t;v[4];main(){fork(fork(fork(t=time(0))));while(time(0)<=t+9);wait(0);wait(0);wait(0)>0&&(times(v),printf("%d,%d",v[0],v[2]));}

Образец вывода:

906,6347

что означает 9,06 секунд реального времени и 63,47 секунд общего времени процессора.

Для -std=c90 -m32достижения наилучших результатов скомпилируйте с помощью (принудительное использование 32-битного кода на 64-битной машине).

PowerShell v4, 144 байта

$d=date;gjb|rjb
1..20|%{sajb{$x=date;sleep 3;((date)-$x).Ticks/1e7}>$null}
while(gjb -s "Running"){}(gjb|rcjb)-join'+'|iex
((date)-$d).Ticks/1e7

Устанавливает $dравным Get-Dateи очищает любые существующие истории заданий с Get-Job | Remove-Job. Затем мы 1..20|%{...}выполняем цикл и выполняем каждую итерацию, Start-Jobпередавая ему блок сценария {$x=date;sleep 3;((date)-$x).ticks/1e7}для задания (то есть каждое задание будет выполнять этот блок сценария). Мы направляем этот вывод для >$nullподавления обратной связи (т. Е. Имени задания, статуса и т. Д.), Которая возвращается.

Блок сценария устанавливается $xна Get-Date, затем Start-Sleepна 3несколько секунд, затем принимает новое Get-Dateчтение, вычитает $x, получает .Ticksи делит на, 1e7чтобы получить секунды (с точностью).

Вернемся к основной теме, пока любая работа по-прежнему -Sтатус "Running", мы вращаемся внутри пустой whileпетли. Как только это будет сделано, мы будем Get-Jobизвлекать объекты для всех существующих заданий, направлять те, в Receive-Jobкоторые будет извлекать эквивалент STDOUT (то есть то, что они выводят), -joinрезультаты вместе с ними +и направлять iex( Invoke-Expressionи аналогично eval). Это выведет итоговое время ожидания плюс накладные расходы.

Последняя строка похожа в том, что она получает новую дату, вычитает исходную отметку даты $d, получает .Ticksи делит 1e7для вывода общего времени выполнения.

NB

Хорошо, так что это немного изгиба правил. По-видимому, при первом выполнении PowerShell необходимо загрузить несколько сборок .NET с диска для различных операций с потоками, поскольку они не загружены с профилем оболочки по умолчанию. Последующие исполнения, поскольку сборки уже находятся в памяти, работают нормально. Если вы оставите окно оболочки в бездействии достаточно долго, вы получите встроенную сборку мусора PowerShell и разгрузите все эти сборки, в результате чего следующее выполнение займет много времени, так как он перезагружает их. Я не уверен, что можно обойти это.

Вы можете увидеть это во время выполнения в следующих запусках. Я запустил новую оболочку, перешел к своему каталогу по гольфу и выполнил сценарий. Первый запуск был ужасным, но второй (выполненный немедленно) работал нормально. Затем я оставил оболочку на несколько минут бездействующей, чтобы позволить сборке мусора, и затем этот цикл снова стал длительным, но последующие циклы снова работают нормально.

Пример работает

Windows PowerShell
Copyright (C) 2014 Microsoft Corporation. All rights reserved.

PS H:\> c:

PS C:\> cd C:\Tools\Scripts\golfing

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
63.232359
67.8403415

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.0809705
8.8991164

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
62.5791712
67.3228933

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.1303589
8.5939405

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.3210352
8.6386886

PS C:\Tools\Scripts\golfing>

Javascript (ES6), 212 203 145 байт

Этот код создает 10 изображений с интервалом времени ровно 6 секунд каждое при загрузке.

Время выполнения чуть выше (из-за накладных расходов).

Этот код перезаписывает все в документе!

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,6e3) >'.repeat(i=10)

Это предполагает, что вы используете однобайтовую кодировку для обратных ссылок, которая необходима для того, чтобы механизм Javascript не отключался.

В качестве альтернативы, если вы не хотите тратить 6 секунд на ожидание, вот решение длиной в 1 байт, которое заканчивается менее чем за секунду:

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,600) >'.repeat(i=100)

Разница в том, что этот код ожидает 600 мс на 100 изображениях. Это даст огромное количество накладных расходов.

Старая версия (203 байта):

Этот код создает 10 фреймов с интервалом времени ровно 6 секунд каждый вместо создания 10 изображений.

for(P=performance,M=P.now(T=Y=i=0),D=document,X=_=>{T+=_,--i||alert([P.now()-M,T])};i<10;i++)I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)

Оригинальная версия (212 байт):

P=performance,M=P.now(T=Y=0),D=document,X=_=>{T+=_,Y++>8&&alert([P.now()-M,T])},[...''+1e9].map(_=>{I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)})

Руби, 92

n=->{Time.now}
t=n[]
a=0
(0..9).map{Thread.new{b=n[];sleep 6;a+=n[]-b}}.map &:join
p n[]-t,a

Javascript (ES6), 108 92 байта

Я делаю новый ответ, так как он использует немного другой подход.

Он генерирует огромное количество setTimeouts, которые почти все выполняются с 4 мс между ними.

Каждый интервал составляет 610 миллисекунд, в общей сложности 99 интервалов.

M=(N=Date.now)(T=Y=0),eval('setTimeout("T+=N()-M,--i||alert([N()-M,T])",610);'.repeat(i=99))

Обычно он выполняется в течение 610 мс, общее время выполнения составляет около 60,5 секунд.

Это было проверено на Google Chrome версии 51.0.2704.84 m, на Windows 8.1 x64.

Старая версия (108 байт):

P=performance,M=P.now(T=Y=0),eval('setTimeout("T+=P.now()-M,--i||alert([P.now()-M,T])",610);'.repeat(i=99))

Царапина - 164 байта (16 блоков)

when gf clicked
set[t v]to[
repeat(9
  create clone of[s v
end
wait until<(t)>[60
say(join(join(t)[ ])(timer
when I start as a clone
wait(8)secs
change[t v]by(timer

Смотрите это в действии здесь .

Использует переменную с именем 't' и спрайт с именем 's'. Спрайт создает своих клонов, каждый из которых ожидает 8 секунд, и увеличивает переменную, синхронизирующую все время ожидания. В конце указывается общее время выполнения и общее время ожидания (например, 65.488 8.302).

Clojure, 135 120 111 109 байт

(let[t #(System/nanoTime)s(t)f #(-(t)%)][(apply +(pmap #(let[s(t)](Thread/sleep 7e3)%(f s))(range 9)))(f s)])

Отформатированная версия с именованными переменными:

(let [time #(System/currentTimeMillis)
      start (time)
      fmt #(- (time) %)]
  [(apply +
           (pmap #(let [thread-start (time)]
                   (Thread/sleep 7e3)
                   %
                   (fmt thread-start)) (range 9)))
   (fmt start)])

выход (в наносекундах):

[62999772966 7001137032]

Изменен формат. Спасибо Адам, я мог пропустить эту спецификацию формата в вопросе, когда я читал ее.

Изменено на nanoTime для игры в гольф.

Спасибо Cliffroot, я полностью забыл о научных обозначениях и не могу поверить, что я не видел apply. Я думаю, что использовал это в чем-то, что я вчера играл в гольф, но никогда не писал. Вы спасли мне 2 байта.

Ржавчина, 257 , 247 байт

Я использую то же время, что и в ответе Mego на Python.

На самом деле единственный немного умный бит использует ii, чтобы получить длительность 0 секунд.

fn main(){let n=std::time::Instant::now;let i=n();let h:Vec<_>=(0..8).map(|_|std::thread::spawn(move||{let i=n();std::thread::sleep_ms(9000);i.elapsed()})).collect();let mut t=i-i;for x in h{t+=x.join().unwrap();}print!("{:?}{:?}",t,i.elapsed());}

Печать:

Duration { secs: 71, nanos: 995877193 }Duration { secs: 9, nanos: 774491 }

Ungolfed:

fn main(){
    let n = std::time::Instant::now;
    let i = n();
    let h :Vec<_> =
        (0..8).map(|_|
            std::thread::spawn(
                move||{
                    let i = n();
                    std::thread::sleep_ms(9000);
                    i.elapsed()
                }
            )
        ).collect();
    let mut t=i-i;
    for x in h{
        t+=x.join().unwrap();
    }
    print!("{:?}{:?}",t,i.elapsed());
}

Редактировать: старый добрый цикл немного короче

JavaScript (ES6, используя WebWorkers), 233 215 байтов

c=s=0;d=new Date();for(i=14;i-->0;)(new Worker(URL.createObjectURL(new Blob(['a=new Date();setTimeout(()=>postMessage(new Date()-a),5e3)'])))).onmessage=m=>{s+=m.data;if(++c>13)console.log((new Date()-d)/1e3,s/1e3)}

UPD: заменил способ выполнения работника из строки на более компактный и кросс-браузерный в аспекте политик кросс-происхождения. Не будет работать в Safari, если в нем все еще есть webkitURLобъект URL, и в IE.

Python 2, 130 байт

import thread as H,time as T
m=T.clock;T.z=m()
def f(k):T.sleep(k);T.z+=m()
exec"H.start_new_thread(f,(7,));"*9
f(8);print m(),T.z

Это вывод ответа Мего, но он достаточно отличается, так что я подумал, что это должен быть отдельный ответ. Протестировано для работы на Windows.

По сути, он разветвляет 9 потоков, которые спят в течение 7 секунд, в то время как родитель спит в течение 8. Затем он распечатывает время. Образец вывода:

8.00059192923 71.0259046024

В Windows time.clockизмеряет время ожидания после первого звонка.

Perl 6, 72 71 байт

Там может быть более короткий способ сделать это

say sum await map {start {sleep 7;now -ENTER now}},^9;say now -INIT now

это выводы

63.00660729694
7.0064013

Mathematica, 109 байт

a=AbsoluteTiming;LaunchKernels@7;Plus@@@a@ParallelTable[#&@@a@Pause@9,{7},Method->"EvaluationsPerKernel"->1]&

Анонимная функция. Требуется лицензия с 7+ ядрами для запуска. Занимает 9 секунд в реальном времени и 63 секунды в режиме ядра, без учета накладных расходов. Убедитесь, что предыдущие операторы выполняются только один раз (чтобы они не пытались перезапустить ядра). Тестирование:

In[1]:= a=AbsoluteTiming;LaunchKernels@7;func=Plus@@@a@ParallelTable[#&@@a@Pause
@9,{7},Method->"EvaluationsPerKernel"->1]&;

In[2]:= func[]

Out[2]= {9.01498, 63.0068}

In[3]:= func[]

Out[3]= {9.01167, 63.0047}

In[4]:= func[]

Out[4]= {9.00587, 63.0051}

Javascript (ES6), 105 байт

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},8e3,c,t())})(Date.now,8,0)

Обновленная версия: 106 байт Заимствовано у @Ismael Miguel, поскольку у него была прекрасная идея уменьшить время сна и увеличить интервалы.

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},610,c,t())})(Date.now,99,0)

Javascript Ungolfed, 167 байтов

(function(t, c, d){
	i = t();
	while(c--){
		setTimeout(function(c, s){
			d += t() - s;
			if (!c) alert([t() - i, d])
		}, 8e3, c, t())
	}
})(Date.now, 8, 0)

Ява, 358 343 337 316 313 байт

import static java.lang.System.*;class t extends Thread{public void run(){long s=nanoTime();try{sleep(999);}catch(Exception e){}t+=nanoTime()-s;}static long t,i,x;public static void main(String[]a)throws Exception{x=nanoTime();for(;++i<99;)new t().start();sleep(9000);out.println((nanoTime()-x)/1e9+" "+t/1e9);}}

и без золота

import static java.lang.System.*;

class t extends Thread {
    public void run() {
        long s = nanoTime();
        try {
            sleep(999);
        } catch (Exception e) {
        }
        t += nanoTime() - s;
    }

    static long t,i,x;

    public static void main(String[] a) throws Exception {
        x = nanoTime();
        for (; ++i < 99;)
            new t().start();
        sleep(9000);
        out.println((nanoTime() - x) / 1e9 + " " + t / 1e9);
    }
}

пожалуйста, не пытайтесь сделать это дома, так как это решение не безопасно.

Редактировать:

Я принял предложения @A Boschman и @ Adám, и теперь моей программе требуется менее 10 секунд для запуска, и она короче на 15 байтов.

С (с нитями), 339 336 335 байт

#include<stdio.h>
#include<sys/time.h>
#include<pthread.h>
#define d double
d s=0;int i;pthread_t p[14];d t(){struct timeval a;gettimeofday(&a,NULL);return a.tv_sec+a.tv_usec/1e6;}
h(){d b=t();sleep(5);s+=t()-b;}
main(){d g=t();for(i=14;i-->0;)pthread_create(&p[i],0,&h,0);for(i=14;i-->0;)pthread_join(p[i],0);printf("%f %f",t()-g,s);}

C90 (OpenMP), 131 байт (+ 17 для переменной env) = 148 байт

#include <omp.h>
#define o omp_get_wtime()
n[4];main(t){t=o;
#pragma omp parallel
while(o-9<t);times(n);printf("%d,%f",n[0],o-t);}

Пример вывода:

7091,9.000014

Примечания:

7091 находится в циклах (100 / сек), поэтому программа работала в течение 70 секунд

Может быть намного короче, если бы я нашел способ заставить работать таймер, отличный от omp_get_wtime (), потому что тогда я мог бы также удалить оператор include.

Запустить с OMP_NUM_THREADS = 9

Common Lisp (SBCL) 166 байт:

(do((m #1=(get-internal-real-time))(o(list 0)))((>(car o)60000)`(,(car o),(- #1#m)))(sb-thread:make-thread(lambda(&aux(s #1#))(sleep 1)(atomic-incf(car o)(- #1#s)))))

Это просто порождает потоки, которые спят, а затем атомарно увеличивают время, которое требуется, с внешним циклом, который вращается, ожидая, что общее время будет больше 60000 тиков (то есть 60 секунд на sbcl). Счетчик хранится в списке из-за ограничений типов мест, которые может изменить atomic-incf. Это может закончиться, прежде чем завершится на более быстрых машинах.

Ungolfed:

(do ((outer-start (get-internal-real-time))
       (total-inner (list 0)))
      ((> (car total-inner) 60000)
       `(,(car total-inner)
      ,(- (get-internal-real-time) outer-start)))
    (sb-thread:make-thread
     (lambda (&aux(start (get-internal-real-time)))
       (sleep 1)
       (atomic-incf (car total-inner) (- (get-internal-real-time) start)))))

Perl, 101 байт

use Time::HiRes<time sleep>;pipe*1=\time,0;
print time-$1,eval<1>if open-print{fork&fork&fork}-sleep 9

Форкс 7 дочерних процессов, каждый из которых ждет 9 секунд.

Пример вывода:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 персонажа

d={new Date().getTime()}
s=d(j=0)
8.times{Thread.start{b=d(m=1000)
sleep 8*m
synchronized(j){j+=d()-b}}}addShutdownHook{print([(d()-s)/m,j/m])}

Образец прогона:

bash-4.3$ groovy wait1minute.groovy
[8.031, 64.055]

Эликсир, 168 байт

import Task;import Enum;IO.puts elem(:timer.tc(fn->IO.puts(map(map(1..16,fn _->async(fn->:timer.tc(fn->:timer.sleep(4000)end)end)end),&(elem(await(&1),0)))|>sum)end),0)

Образец прогона:

$ elixir thing.exs
64012846
4007547

Выходными данными является общее время ожидания, за которым следует время, в течение которого программа работала, в микросекундах.

Программа порождает 14 Taskс, и ждет каждого из них, сопоставляя их, а затем находит сумму их прошедшего времени. Он использует Эрланга timerдля измерения времени.

Haskell, 278 271 262 246 байт

import Control.Concurrent.Chan
import Data.Time
import GHC.Conc
t=getCurrentTime
b!a=b=<<flip diffUTCTime<$>t<*>(a>>t)
w=threadDelay$5^10
0#_=t
i#a=a>>(i-1)#a
main=print!do r<-newChan;9#(forkIO$writeChan r!w);getChanContents r>>=print.sum.take 9

!измеряет время, затраченное действием a(второй аргумент) и применяет b(первый аргумент) к результату.

w это функция сна.

mainизмеряется сам, и результат печатается ( print!...).

#есть replicateMповторение данного действия N раз (и возвращение tиз-за игры в гольф).

Внутри измеряемой части 9 потоков ( replicate 9 $ forkIO ...) спят в течение 5^10миллисекунд (9,765625 секунд) и отправляют результат ( writeChan) в канал, созданный основным потоком ( newChan), который суммирует 9 результатов и печатает итог ( getChanContents >>= print . sum . take 9).

Выход:

87.938546708s
9.772032144s

Python 2, 132 байта

Использует пул процессов, чтобы порождать 9 процессов и дать каждому спать в течение 7 секунд.

import time as t,multiprocessing as m
def f(x):d=s();t.sleep(x);return s()-d
s=t.time
a=s()
print sum(m.Pool(9).map(f,[7]*9)),s()-a

Сначала выводится общее накопленное время сна, а затем фактическое время выполнения:

$ python test.py
63.0631158352 7.04391384125

Рубин (с parallelжемчужиной), 123 116 байт

require'parallel'
n=->{Time.now}
t=n[]
q=0
Parallel.each(1..10,:in_threads=>10){z=n[];sleep 6;q+=n[]-z}
puts n[]-t,q

Изменить: Добавлена ​​ссылка "Time.now" из ответа Руби гистократ.

Matlab, 75 байт

tic;parpool(9);b=1:9;parfor q=b
a=tic;pause(7);b(q)=toc(a);end
[sum(b);toc]

Краткое объяснение: parforсоздает параллельный цикл for, распределенный по пулу рабочих. ticи tocизмерять прошедшее время (и, по моему мнению, это одна из лучших функций MATLAB). Последняя строка (массив с общим временем ожидания и прошедшим в реальном времени) выводится, поскольку она не заканчивается точкой с запятой.

Обратите внимание, что это создает колоссальные 9 полноценных процессов MATLAB. Тогда есть вероятность, что эта конкретная программа не будет завершена в течение выделенных 10 секунд на вашем компьютере. Тем не менее, я думаю, что с установкой MATLAB, в которой нет наборов инструментов, за исключением установленного набора инструментов для параллельных вычислений, установленного в высокопроизводительной системе с SSD, можно завершить работу в течение 10 секунд. При необходимости вы можете настроить параметры, чтобы меньше процессов спало больше.