งาน

ใช้การขนานใด ๆ ให้รอหลายช่วงเวลารวมเวลาพักอย่างน้อยหนึ่งนาที (แต่น้อยกว่าหนึ่งนาทีครึ่ง)

โปรแกรม / ฟังก์ชั่นจะต้องสิ้นสุดภายใน 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]) โชคไม่ดีที่ในกรณีส่วนใหญ่ไบต์ที่ได้รับจากการทำเช่นนี้จะหายไปโดยจำเป็นต้องสร้างวัตถุที่อนุญาตให้สร้างแอตทริบิวต์ที่ผู้ใช้กำหนดเองได้ที่รันไทม์ โชคดีที่ฟังก์ชั่นรองรับคุณลักษณะที่ผู้ใช้กำหนดที่รันไทม์ดังนั้นผมจึงใช้ประโยชน์จากนี้โดยการบันทึกเวลารวมในแอตทริบิวต์ของtf

ลองออนไลน์

ขอบคุณ 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ปฏิบัติการแทนของเปลือก builtin โดย prefixing \ด้วย

ต่อท้ายไฟล์jซึ่งต้องว่างเปล่าหรือไม่มีอยู่ในตอนเริ่มต้น

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

เอาท์พุท (ms): 160.9939ms, 60001 (160ms เพื่อรอ 60.001 วินาที)

Bash 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 ไบต์ (หมุน CPU)

วิธีนี้จะทำให้ CPU หมุนแทนการนอนหลับและนับเวลาโดยใช้timesฟังก์ชั่น POSIX (ซึ่งจะวัดเวลา CPU ที่ใช้โดยกระบวนการหลักและในการรอลูก - ทั้งหมด)

มันหยุดกระบวนการ 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 วินาทีและเวลา CPU ทั้งหมด 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)

นี่ถือว่าคุณใช้การเข้ารหัสไบต์เดียวสำหรับ backticks ซึ่งจำเป็นสำหรับเอ็นจิน 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)

ความแตกต่างคือรหัสนี้รอ 600ms ใน 100 ภาพ สิ่งนี้จะทำให้เกิดเป็นจำนวนมหาศาลของค่าใช้จ่าย

รุ่นเก่า (203 ไบต์):

รหัสนี้จะสร้าง iframe 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 ไบต์

ฉันกำลังทำคำตอบใหม่เนื่องจากใช้ 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))

มันมักจะทำงานภายใน 610ms เป็นเวลาดำเนินการทั้งหมดประมาณ 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 ไบต์

ฉันใช้เวลาเดียวกับคำตอบ Python ของ Mego

จริงๆแล้วบิตที่ฉลาดเพียงเล็กน้อยเท่านั้นที่ใช้ 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());
}

แก้ไข: old old for loop นั้นสั้นกว่าเล็กน้อย

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

นี่เป็นคำตอบที่มาจาก Mego แต่มันแตกต่างกันมากพอที่ฉันคิดว่ามันควรจะเป็นคำตอบที่แยกจากกัน ผ่านการทดสอบการทำงานบน 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)

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

และ 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 ไบต์ (+ 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 เห็บ (เช่น 60s บน 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]

Elixir, 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สำหรับการวัดเวลา

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" จากคำตอบ Ruby โดย histocrat

Matlab, 75 ไบต์

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

คำอธิบายอย่างรวดเร็ว: parforสร้างขนานสำหรับวงวนกระจายข้ามกลุ่มคนงาน ticและtocวัดเวลาที่ผ่านไป (และในความคิดของฉันเป็นหนึ่งในฟังก์ชั่นที่มีชื่อที่ดีที่สุดใน MATLAB) บรรทัดสุดท้าย (อาร์เรย์ที่มีเวลารวมทั้งหมดและเวลาจริงผ่านไป) จะถูกเอาท์พุทเนื่องจากมันไม่ได้จบด้วยเซมิโคลอน

อย่างไรก็ตามโปรดทราบว่าสิ่งนี้จะสร้างกระบวนการ MATLAB แบบเต็มเปี่ยมจำนวน 9 อัน โอกาสที่โปรแกรมนี้จะไม่เสร็จสิ้นภายใน 10 วินาทีบนเครื่องของคุณ อย่างไรก็ตามฉันคิดว่าด้วยการติดตั้ง MATLAB ที่ไม่มีกล่องเครื่องมือยกเว้นกล่องเครื่องมือ Parallel Computing ที่ติดตั้ง - ติดตั้งบนระบบระดับสูงด้วย SSD - อาจทำได้ภายใน 10 วินาที หากจำเป็นคุณสามารถปรับแต่งพารามิเตอร์เพื่อให้กระบวนการทำงานน้อยลงมากขึ้น