วิธีการเริ่มต้นเธรดสองเธรดที่“ ตรงกัน” ในเวลาเดียวกัน

เธรดควรเริ่มต้นในเสี้ยววินาทีเดียวกัน ผมเข้าใจว่าถ้าคุณทำมันจะใช้เวลามิลลิวินาทีก่อนที่จะดำเนินการต่อไปของthread1.start()thread2.start()

มันเป็นไปได้หรือเป็นไปไม่ได้?

ในการเริ่มต้นเธรดในเวลาเดียวกัน (อย่างน้อยที่สุดเท่าที่จะเป็นไปได้) คุณสามารถใช้CyclicBarrier :

// We want to start just 2 threads at the same time, but let's control that 
// timing from the main thread. That's why we have 3 "parties" instead of 2.
final CyclicBarrier gate = new CyclicBarrier(3);

Thread t1 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};
Thread t2 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};

t1.start();
t2.start();

// At this point, t1 and t2 are blocking on the gate. 
// Since we gave "3" as the argument, gate is not opened yet.
// Now if we block on the gate from the main thread, it will open
// and all threads will start to do stuff!

gate.await();
System.out.println("all threads started");

ไม่จำเป็นต้องเป็น a CyclicBarrierคุณสามารถใช้CountDownLatchหรือแม้แต่ตัวล็อก

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

บนแพลตฟอร์มอื่น ๆ หัวข้อที่เริ่มต้นว่าอาจจะเป็นความต้องการที่ถูกต้องมากครับ

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

แก้ไข: (เพื่อตอบสนองต่อความคิดเห็นบางส่วน) เป็นข้อกำหนดที่ถูกต้องอย่างสมบูรณ์ในการซิงโครไนซ์สถานะหรือความคืบหน้าของหลายเธรดและCyclicBarrierเป็นเครื่องมือที่ยอดเยี่ยม ฉันตอบคำถามไม่ว่าจะเป็นไปได้ที่จะเริ่มต้นหลายหัวข้อที่ตรงเวลาเดียวกัน CyclicBarrierจะรับประกันได้ว่าหัวข้อดำเนินการต่อเมื่อพวกเขาอยู่ตรงที่ของรัฐที่ต้องการ แต่ก็ไม่ได้รับประกันว่าพวกเขาจะเริ่มต้นหรือประวัติส่วนตัวที่ว่าในเวลาเดียวกันถึงแม้ว่ามันอาจจะสวยใกล้เคียง ไม่มีการกล่าวถึงความต้องการในการซิงโครไนซ์ในคำถาม

คุณสามารถใช้ CountDownLatch สำหรับสิ่งนี้ โปรดดูตัวอย่างด้านล่าง แม้ว่า t1 และ t2 จะเริ่มต้นขึ้น แต่เธรดเหล่านี้จะรอจนกว่าเธรดหลักจะนับสลัก จำนวนการนับถอยหลังที่ต้องการถูกกล่าวถึงในตัวสร้าง นอกจากนี้ยังสามารถใช้สลักนับถอยหลังเพื่อรอให้เธรดดำเนินการเสร็จสิ้นเพื่อให้เธรดหลักสามารถดำเนินการต่อไปได้ (กรณีย้อนกลับ) คลาสนี้ถูกรวมไว้ตั้งแต่ Java 1.5

import java.util.concurrent.CountDownLatch;


public class ThreadExample
{
    public static void main(String[] args) 
    {
        CountDownLatch latch = new CountDownLatch(1);
        MyThread t1 = new MyThread(latch);
        MyThread t2 = new MyThread(latch);
        new Thread(t1).start();
        new Thread(t2).start();
        //Do whatever you want
        latch.countDown();          //This will inform all the threads to start
        //Continue to do whatever
    }
}

class MyThread implements Runnable
{
    CountDownLatch latch;
    public MyThread(CountDownLatch latch) 
    {
        this.latch = latch;
    }
    @Override
    public void run() 
    {
        try 
        {
            latch.await();          //The thread keeps waiting till it is informed
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //Do the actual thing
    }
}

1. ตามที่ฉันเข้าใจ JVM ส่วนใหญ่มอบหมายสิ่งนี้ให้กับระบบปฏิบัติการ ดังนั้นคำตอบจะเป็นเฉพาะระบบปฏิบัติการ
2. เป็นไปไม่ได้อย่างชัดเจนในเครื่องที่มีโปรเซสเซอร์เดียว
3. มีความซับซ้อนมากขึ้นเมื่อเทียบกับเครื่องมัลติโปรเซสเซอร์ ตามทฤษฎีสัมพัทธภาพพร้อมกัน "เป็นไปไม่ได้ที่จะพูดในแง่ที่แน่นอนว่าเหตุการณ์สองเหตุการณ์เกิดขึ้นในเวลาเดียวกันหรือไม่หากเหตุการณ์เหล่านั้นถูกแยกออกจากกันในอวกาศ" ไม่ว่าโปรเซสเซอร์ของคุณจะอยู่ใกล้แค่ไหนหน่วยประมวลผลกลางเหล่านั้นก็แยกออกจากกันในอวกาศ
   1. หากคุณสามารถยอมรับความสัมพันธ์พร้อมกันได้ก็น่าจะง่ายกว่าเพียงแค่จำลองโดยใช้เทคนิคที่กล่าวถึงในคำตอบอื่น ๆ