【问题标题】:Java: tutorials/explanations of jsr166y PhaserJava:jsr166y Phaser的教程/解释
【发布时间】:2011-10-13 10:33:38
【问题描述】:

This question 两年前被问到,但它提到的资源不是很有帮助(恕我直言)或链接不再有效。

必须有一些好的教程来理解Phaser。我已经阅读了 javadoc,但是我的眼睛呆滞了,因为为了真正理解 javadoc,您必须知道这些类应该如何使用。

大家有什么建议吗?

【问题讨论】:

标签: java concurrency phaser


【解决方案1】:

对于 Phaser,我已经回答了几个问题。看到它们可能有助于理解它们的应用。它们在底部链接。但是要了解 Phaser 的作用以及为什么它有用,了解它解决了什么很重要。

这里是 CountdownLatch 和 CyclicBarrier 的属性

注意:

  • 参与方数量是不同线程数的另一种说法
  • 不可重用意味着您必须创建一个新的实例 重用前的障碍
  • 如果线程可以到达并继续工作,则屏障是可推进的 无需等待其他线程或可以等待所有线程完成

CountdownLatch

  • 固定人数
  • 不可恢复
  • 先进(看latch.countDown();先进 latch.await(); 必须等待)

循环障碍

  • 固定人数
  • 可重复使用
  • 不可推进

所以 CountdownLatch 是不可重复使用的,你必须每次都创建一个新实例,但它是可重复的。 CylicBarrier 可以重复使用,但所有线程必须等待每一方到达屏障。

移相器

  • 动态参与人数
  • 可重复使用
  • 先进的

当一个线程想要被 Phaser 知道时,他们调用phaser.register(),当线程到达屏障时,他们调用phaser.arrive()这是可以推进的地方。如果线程要等待所有注册的任务完成phaser.arriveAndAwaitAdvance()

还有一个阶段的概念,其中线程可以等待可能尚未完成的其他操作的完成。一旦所有线程都到达移相器的屏障,就会创建一个新阶段(增量为 1)。

你可以看看我的其他答案,也许会有所帮助:

Java ExecutorService: awaitTermination of all recursively created tasks

Flexible CountDownLatch?

【讨论】:

    【解决方案2】:

    至少对于Phaser,我认为JavaDoc 提供了相当清晰的解释。这是一个用于同步一批线程的类,从某种意义上说,您可以使用Phaser 注册批处理中的每个线程,然后使用Phaser 让它们阻塞,直到批处理中的每个线程都有通知Phaser,此时任何阻塞的线程都将开始执行。该等待/通知周期可以根据需要/要求一遍又一遍地重复。

    他们的示例代码给出了一个合理的例子(虽然我非常不喜欢他们的 2 字符缩进样式):

    void runTasks(List<Runnable> tasks) {
       final Phaser phaser = new Phaser(1); // "1" to register self
       // create and start threads
       for (final Runnable task : tasks) {
         phaser.register();
         new Thread() {
           public void run() {
             phaser.arriveAndAwaitAdvance(); // await all creation
             task.run();
           }
         }.start();
       }
    
       // allow threads to start and deregister self
       phaser.arriveAndDeregister();
     } 
    

    这会设置一个注册计数为tasks.size() + 1 的Phaser,并为每个任务创建一个新的Thread,它将阻塞直到Phaser 的下一次推进(即tasks.size() + 1 的时间)到达已被记录),然后运行其相关任务。创建的每个Thread 也会立即启动,因此Phaser 会退出循环并记录tasks.size() 到达。

    对phaser.arriveAndDeregister() 的最终调用将记录最终到达,并减少注册计数,使其现在等于tasks.size()。这会导致Phaser 前进,这实际上允许所有任务同时开始运行。这可以通过执行以下操作来重复:

    void runTasks(List<Runnable> tasks) {
       final Phaser phaser = new Phaser(1); // "1" to register self
       // create and start threads
       for (final Runnable task : tasks) {
         phaser.register();
         new Thread() {
           public void run() {
             while (true) {
               phaser.arriveAndAwaitAdvance(); // await all creation
               task.run();
             }
           }
         }.start();
       }
    
       // allow threads to start and deregister self
       phaser.arriveAndDeregister();
     }
    

    ...这和以前一样,只是添加了一个循环,导致任务重复运行。因为每次迭代调用phaser.arriveAndAwaitAdvance(),任务线程的执行将被同步,这样task-0 不会开始第二次迭代,直到所有其他任务完成第一次迭代并通知准备开始第二次迭代的Phaser迭代。

    如果您正在运行的任务的执行时间差异很大,并且如果您想确保较快的线程不会与较慢的线程不同步,这可能会很有用。

    对于可能的现实应用程序,请考虑运行单独的图形和物理线程的游戏。如果图形线程卡在第 6 帧上,您不希望物理线程计算第 100 帧的数据,并且使用 Phaser 是确保图形和物理线程始终在同一帧上工作的一种可能方法同时(而且,如果一个线程比另一个线程慢得多,则较快的线程会优雅地产生 CPU 资源,因此希望较慢的线程可以更快地赶上)。

    【讨论】:

    • @Jason - 不,不是,仔细看。第二个代码清单在Thread 内有一个while (true) {} 循环,紧跟在public void run() 之后。
    • 啊。知道了。如果你引用 javadoc,你应该使用他们的代码来处理终止。
    【解决方案3】:

    Phaser 与 CyclicBarrier 和 CountDownLatch 的功能有些相似,但它提供的灵活性比这两者都高。

    在 CyclicBarrier 中,我们曾经在构造函数中注册方,但 Phaser 为我们提供了随时注册和取消注册方的灵活性。 对于注册方,我们可以使用以下任何一种 -

    • 构造函数
    • 注册,或
    • 批量注册

    对于deRegistering方,我们可以使用 -

    • arriveAndDeregister,或


    注册- 向此移相器添加/注册新的未到达方。它返回

    • 此注册应用到的到达阶段编号。
    • 如果移相器已终止,则值为负数且注册无效。

    如果 onAdvance() 方法的调用正在进行中,则在返回此方法之前可能会等待其完成。 如果此移相器有父移相器,并且此移相器没有注册方,则此子移相器也向其父移相器注册。
    Phaser 用法演示程序>

    import java.util.concurrent.Phaser;
    
    public class PhaserTest {
    public static void main(String[] args) {
    
           /*Creates a new phaser with 1 registered unArrived parties 
            * and initial phase number is 0
            */
           Phaser phaser=new Phaser(1);
           System.out.println("new phaser with 1 registered unArrived parties"
                        + " created and initial phase  number is 0 ");
    
           //Create 3 threads
           Thread thread1=new Thread(new MyRunnable(phaser,"first"),"Thread-1");
           Thread thread2=new Thread(new MyRunnable(phaser,"second"),"Thread-2");
           Thread thread3=new Thread(new MyRunnable(phaser,"third"),"Thread-3");
    
           System.out.println("\n--------Phaser has started---------------");
           //Start 3 threads
           thread1.start();
           thread2.start();
           thread3.start();
    
           //get current phase
           int currentPhase=phaser.getPhase();
           /*arriveAndAwaitAdvance() will cause thread to wait until current phase
            * has been completed i.e. until all registered threads
            * call arriveAndAwaitAdvance()
            */
           phaser.arriveAndAwaitAdvance();
           System.out.println("------Phase-"+currentPhase+" has been COMPLETED----------");
    
           //------NEXT PHASE BEGINS------
    
           currentPhase=phaser.getPhase();
           phaser.arriveAndAwaitAdvance();
           System.out.println("------Phase-"+currentPhase+" has been COMPLETED----------");
    
           /* current thread Arrives and deRegisters from phaser.
            * DeRegistration reduces the number of parties that may
            * be required to advance in future phases.
            */
           phaser.arriveAndDeregister();
    
           //check whether phaser has been terminated or not.
           if(phaser.isTerminated())
                  System.out.println("\nPhaser has been terminated");
    
    } 
    }
    
    
    
    
    
    class MyRunnable implements Runnable{
    
    Phaser phaser;
    
    MyRunnable(Phaser phaser,String name){
           this.phaser=phaser;
           this.phaser.register(); //Registers/Add a new unArrived party to this phaser.
           System.out.println(name +" - New unarrived party has "
                        + "been registered with phaser");
    }
    
    @Override
    public void run() {
           System.out.println(Thread.currentThread().getName() +
                        " - party has arrived and is working in "
                        + "Phase-"+phaser.getPhase());
           phaser.arriveAndAwaitAdvance();
    
           //Sleep has been used for formatting output
           try {
                  Thread.sleep(1000);
           } catch (InterruptedException e) {
                  e.printStackTrace();
           }
    
           //------NEXT PHASE BEGINS------
    
           System.out.println(Thread.currentThread().getName() +
                        " - party has arrived and is working in "
                        + "Phase-"+phaser.getPhase());
           phaser.arriveAndAwaitAdvance();  
    
           phaser.arriveAndDeregister();
    }
    

    }


    批量注册 - 向此移相器添加新的未到达参与方的参与方数量。它返回

    • 此注册应用到的到达阶段编号。
    • 如果移相器已终止,则值为负数且注册无效。

    如果 onAdvance() 方法的调用正在进行中,则在返回此方法之前可能会等待其完成。

    arriveAndDeregister- 当前线程 (Party) 从移相器到达和取消注册。取消注册减少了未来可能需要进入下一阶段的参与方数量。

    如果此移相器有父移相器,并且此移相器没有注册方,则此子移相器也已向其父移相器注册。 演示父子移相器的程序

    import java.util.concurrent.Phaser;
    
    public class PhaserParentChildTest {
    public static void main(String[] args) {
    
    
        /*
      * Creates a new phaser with no registered unArrived parties.
      */
        Phaser parentPhaser = new Phaser();
    
        /*
      * Creates a new phaser with the given parent &
      * no registered unArrived parties.
      */
        Phaser childPhaser = new Phaser(parentPhaser,0);
    
        childPhaser.register();
    
        System.out.println("parentPhaser isTerminated : "+parentPhaser.isTerminated());
        System.out.println("childPhaser isTerminated : "+childPhaser.isTerminated());
    
        childPhaser.arriveAndDeregister();
        System.out.println("\n--childPhaser has called arriveAndDeregister()-- \n");
    
        System.out.println("parentPhaser isTerminated : "+parentPhaser.isTerminated());
        System.out.println("childPhaser isTerminated : "+childPhaser.isTerminated());
    
    }
    }
    

    在http://www.javamadesoeasy.com/2015/03/phaser-in-java_21.html上阅读有关 Phaser 的更多信息

    【讨论】:

      猜你喜欢
      • 2014-12-11
      • 1970-01-01
      • 2022-12-10
      • 1970-01-01
      • 2011-01-18
      • 1970-01-01
      • 2015-03-23
      • 2016-01-18
      • 1970-01-01
      相关资源
      最近更新 更多