태스크

모든 유형의 병렬 처리를 사용하여 최소 1 분 (1 분 반 미만)의 총 수면 시간 동안 여러 기간을 기다리십시오.

프로그램 / 기능은 10 초 이내에 종료하고 총 경과 시간과 총 실행 된 휴면 시간의 두 가지 값을 어떤 형식 으로든 반환해야합니다. 두 시간 값 모두 0.1 초 이상의 정밀도를 가져야합니다.

이것은 인력 시간 개념과 유사합니다. 60 명의 시간이 걸리는 작업은 10 명의 근로자가 작업을 분할하면 6 시간 만에 완료 될 수 있습니다. 여기서 10 개의 병렬 스레드에서 60 초의 휴면 시간을 가질 수 있으므로 전체 작업을 완료하는 데 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: 모든 스레드가 완료 될 때까지 기다렸다가 각 스레드에 대한 결과를 가져옵니다.
• (⌈/,+/): 하나의 단일 스레드의 가장 긴 실행 시간 (다른 모든 스레드가 실행 된 동안 실행 시간이므로 실제 런타임 임)과 모든 스레드의 실행 시간 합계를 반환합니다.

온라인으로 사용해보십시오!

파이썬 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 초 이상의 시간 정밀도를 가진 OS (즉, 최신 OS)가 필요합니다. 각각 9 초 동안 휴면 상태 인 8 개의 스레드가 생성되어 ~ 9 초의 실시간 런타임과 ~ 72 초의 병렬 런타임이 발생합니다.

비록 공식 문서가 말한다 Thread생성자 키워드 인수로 호출 할 필요가 나는 바람에주의를 던져 어쨌든 위치 인수를 사용합니다. 첫 번째 인수 ( group)는이어야 None하고 두 번째 인수는 대상 함수입니다.

nneonneo는 주석에서 속성 액세스 (예 :) f.t가 목록 인덱스 액세스 (예 :) 보다 짧다 는 의견을 지적했습니다 t[0]. 불행히도, 대부분의 경우, 런타임에 사용자 정의 속성을 생성 할 수있는 객체를 생성해야하므로이 작업을 통해 얻은 몇 바이트가 손실됩니다. 다행히, 함수는 런타임에 사용자 정의 속성을 지원, 그래서 총 시간을 절약하여이를 악용 t의 속성 f.

온라인으로 사용해보십시오

exec트릭을 사용하여 -5 바이트의 DenkerAffe에게 감사드립니다 .

스레드 인수가 필요하지 않음을 지적하여 -7 바이트에 대한 kundor 덕분입니다.

기타 개선으로 -7 바이트의 nneonneo 덕분에.

배쉬 + GNU 유틸리티, 85

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

time접두사 a로 시작하여 쉘 내장 대신 실행 파일을 강제로 사용 합니다 \.

j시작시 비어 있거나 존재하지 않아야 하는 파일에 추가 합니다.

이동-189 바이트

감사합니다 @ 고양이!

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

출력 (ms) : 160.9939ms, 60001 (160.60 초 대기 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처음에 파일이 없다고 가정합니다 .

자바 스크립트 (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]));

총 63 초 (실제로 63.43 시도) 동안 7 초 동안 9 번 기다릴 것을 약속하지만 실제로 시도 할 때 실제로는 7.05 초만 걸립니다.

C, 127 바이트 (CPU 회전)

이 솔루션은 휴면 대신 CPU를 회전시키고 timesPOSIX 기능 (상위 프로세스 및 대기 한 모든 하위에서 소비 된 CPU 시간을 측정)을 사용하여 시간을 계산 합니다.

그것은 각각 9 초 동안 회전하는 7 개의 프로세스를 분기하고 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 초, 총 CPU 시간 63.47 초를 의미합니다.

최상의 결과를 얻으려면 -std=c90 -m32(64 비트 시스템에서 강제 32 비트 코드)로 컴파일하십시오 .

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돌아가서 어떤 작업이 여전히 tatus "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>

자바 스크립트 (ES6) 212 203 145 바이트

이 코드는로드 할 때 각각 정확히 6 초의 시간 간격으로 10 개의 이미지를 만듭니다.

실행 시간은 오버 헤드로 인해 조금 위로 올라갑니다 .

이 코드는 문서의 모든 것을 덮어 씁니다!

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 초 이내에 완료되는 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)

차이점은이 코드는 100 개의 이미지에서 600ms 동안 대기한다는 것입니다. 이로 인해 엄청난 오버 헤드가 발생합니다.

이전 버전 (203 바이트) :

이 코드는 10 개의 이미지를 만드는 대신 정확히 6 초의 시간 간격으로 10 개의 iframe을 만듭니다.

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

자바 스크립트 (ES6) 108 92 바이트

약간 다른 aproach를 사용하기 때문에 새로운 답변을 만들고 있습니다.

그것은 대량의 setTimeouts를 생성하며 , 거의 모두 4ms 사이에서 실행됩니다.

각 간격은 610 밀리 초이며 총 99 개의 간격에 걸쳐 있습니다.

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

일반적으로 약 60.5 초의 총 실행 시간 동안 610ms 이내에 실행됩니다.

이것은 Windows 8.1 x64에서 Chrome 버전 51.0.2704.84 m에서 테스트되었습니다.

이전 버전 (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.

클로저, 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]

형식이 변경되었습니다. 감사합니다 Adám, 나는 그것을 읽을 때 질문에서 해당 형식 사양을 놓쳤을 수 있습니다.

골프 능력을 위해 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 }

언 골프 드 :

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

편집 : 좋은 오래된 for 루프가 조금 짧습니다.

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대신 객체 가 있고 Safari에서는 Safari에서 작동하지 않습니다 URL.

파이썬 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

이것은 Mego의 답변에서 파생되었지만 별도의 답변이어야한다고 생각하는 것과는 완전히 다릅니다. Windows에서 작동하도록 테스트되었습니다.

기본적으로 9 개의 스레드를 제거하여 부모가 8 동안자는 동안 7 초 동안 잠을 자면 시간을 인쇄합니다. 샘플 출력 :

8.00059192923 71.0259046024

Windows에서는 time.clock첫 번째 통화 이후의 월 시간을 측정합니다.

펄 6, 72 71 바이트

이 작업을 수행하는 더 짧은 방법이있을 수 있습니다

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

이 출력

63.00660729694
7.0064013

수학, 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}

자바 스크립트 (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 bytes @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)

자바 스크립트 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)

Java, 33444337316313 바이트

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

그리고 ungolfed

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 바이트가 더 짧습니다.

C (pthreads 포함), 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 바이트 (env 변수의 경우 +17) = 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로 실행

공통 리스프 (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 틱 (즉, sbcl의 60 초)을 기다리는 회전하는 외부 루프와 함께 시간이 걸리는 원자 적으로 증가합니다. 카운터는 atomic-incf가 수정할 수있는 장소 유형의 제한으로 인해 목록에 저장됩니다. 더 빠른 시스템에서 종료하기 전에 공간이 부족할 수 있습니다.

언 골프 드 :

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

펄, 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, 158143 자

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초를 생성 하고 이들을 매핑하여 각각을 기다린 다음 경과 시간의 합계를 찾습니다. Erlang을 사용 timer하여 시간을 측정합니다.

하스켈, 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

파이썬 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젬 포함), 123116 바이트

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

편집 : histocrat의 Ruby 답변에서 "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-loop를 만듭니다. 경과 시간 tic을 toc측정하십시오 (그리고 MATLAB에서 가장 잘 명명 된 함수 중 하나입니다). 마지막 줄 (총 절전 시간과 경과 시간이있는 배열)은 세미콜론으로 끝나지 않기 때문에 출력됩니다.

그러나 이로 인해 무려 9 개의 본격적인 MATLAB 프로세스가 생성됩니다. 그러면이 특정 프로그램이 컴퓨터에서 할당 된 10 초 내에 완료되지 않을 가능성이 있습니다. 그러나 SSD가있는 고급 시스템에 설치된 Parallel Computing 도구 상자를 제외하고 도구 상자가없는 MATLAB 설치를 사용하면 10 초 이내에 완료 될 수 있다고 생각합니다. 필요한 경우 더 적은 수면 프로세스를 갖도록 매개 변수를 조정할 수 있습니다.