ใช้ Grand Central Dispatch ใน Swift เพื่อขนานและเร่งความเร็วลูป "สำหรับ" หรือไม่

"การวนซ้ำแบบมัลติเธรด" สามารถทำได้ด้วย dispatch_apply():

let outerCount = 100    // # of concurrent block iterations
let innerCount = 10000  // # of iterations within each block

let the_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(UInt(outerCount), the_queue) { outerIdx -> Void in
    for innerIdx in 1 ... innerCount {
       // ...
    }
}

(คุณต้องหาความสัมพันธ์ที่ดีที่สุดระหว่างจำนวนภายนอกและภายใน)

มีสองสิ่งที่ควรสังเกต:

• arc4random() ใช้ mutex ภายใน ซึ่งทำให้ช้ามากเมื่อเรียกจากหลายเธรดพร้อมกัน โปรดดูที่ ประสิทธิภาพของโค้ดที่ใช้งานพร้อมกันโดยใช้ Dispatch_group_async นั้นช้ากว่าเวอร์ชันเธรดเดียวมาก จากคำตอบที่ให้ไว้ rand_r() (โดยแยกเมล็ดสำหรับแต่ละเธรด) ดูเหมือนจะเป็นทางเลือกที่เร็วกว่า

• ตัวแปรผลลัพธ์ winner ต้องไม่ได้รับการแก้ไขจากหลายเธรดพร้อมกัน คุณสามารถใช้อาร์เรย์แทนโดยที่แต่ละเธรดอัปเดตองค์ประกอบของตัวเอง และผลลัพธ์จะถูกเพิ่มในภายหลัง มีการอธิบายวิธีการรักษาความปลอดภัยสำหรับเธรดไว้ใน https://stackoverflow.com/a/26790019/1187415

แล้วจะมีลักษณะประมาณนี้:

let outerCount = 100     // # of concurrent block iterations
let innerCount = 10000   // # of iterations within each block

let the_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

var winners = [Int](count: outerCount, repeatedValue: 0)
winners.withUnsafeMutableBufferPointer { winnersPtr -> Void in

    dispatch_apply(UInt(outerCount), the_queue) { outerIdx -> Void in
        var seed = arc4random() // seed for rand_r() in this "thread"

        for innerIdx in 1 ... innerCount {
            var points = 0
            var ability = 500

            for i in 1 ... 1000 {
                let chance = Int(rand_r(&seed) % 1001)
                if chance < (ability-points) { ++points }
                else {points = points - 1}
            }
            if points > 0 {
                winnersPtr[Int(outerIdx)] += 1
            }
        }
    }
}

// Add results:
let winner = reduce(winners, 0, +)
println(winner)

เพียงเพื่ออัปเดตสิ่งนี้สำหรับไวยากรณ์ร่วมสมัย ตอนนี้เราใช้ concurrentPerform (ซึ่งแทนที่ dispatch_apply)

เราจึงสามารถทดแทนได้

for j in 0 ..< 1_000_000 {
    for i in 0 ..< 1000 {
        ...
    }
}

กับ

DispatchQueue.concurrentPerform(1_000_000) { j in
    for i in 0 ..< 1000 {
        ...
    }
}

โปรดทราบว่าการขนานจะทำให้เกิดค่าใช้จ่ายเล็กน้อย ทั้งในกลไกการจัดส่ง GCD พื้นฐาน รวมถึงการซิงโครไนซ์ผลลัพธ์ หากคุณมีการวนซ้ำ 32 ครั้งในการวนซ้ำขนาน สิ่งนี้อาจไม่สำคัญ แต่คุณมีการวนซ้ำเป็นล้านครั้ง และจะเริ่มรวมกัน

โดยทั่วไปเราแก้ปัญหานี้ด้วยการ "ก้าว": แทนที่จะขนานการวนซ้ำ 1 ล้านครั้ง คุณอาจทำซ้ำแบบคู่ขนานได้เพียง 100 ครั้ง โดยแต่ละครั้งทำซ้ำได้ 10,000 ครั้ง เช่น. สิ่งที่ต้องการ:

let totalIterations = 1_000_000
let stride = 10_000
let (quotient, remainder) = totalIterations.quotientAndRemainder(dividingBy: stride)
let iterations = quotient + remainder == 0 ? 0 : 1

DispatchQueue.concurrentPerform(iterations: iterations) { iteration in
    for j in iteration * stride ..< min(totalIterations, (iteration + 1) * stride) {
        for i in 0 ..< 1000 {
            ...
        }
    }
}