Concurrent - Phaser - awaitAdvance & awaitAdvanceInterruptibly

最新推荐文章于 2021-12-23 14:01:31 发布
最新推荐文章于 2021-12-23 14:01:31 发布
阅读量162 收藏
点赞数
分类专栏： Concurrent 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agileforce/article/details/88300761
版权

原创转载请注明出处：http://agilestyle.iteye.com/blog/2344661

 

awaitAdvance(int phase)

awaitAdvance(int phase)作用是如果传入参数phase值和当前getPhase()返回值一样，则在屏障处等待，否则立刻返回执行下面的代码


PhaserTest11.java

package org.fool.java.concurrent.phaser;

import java.util.concurrent.Phaser;

public class PhaserTest11 {
    public static class ThreadA implements Runnable {
        private Phaser phaser;

        public ThreadA(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

            phaser.arriveAndAwaitAdvance();

            System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
        }
    }

    public static class ThreadB implements Runnable {
        private Phaser phaser;

        public ThreadB(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

            phaser.arriveAndAwaitAdvance();

            System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
        }
    }

    public static class ThreadC implements Runnable {
        private Phaser phaser;

        public ThreadC(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

                Thread.sleep(3000);

                System.out.println("phaser.getPhase()=" + phaser.getPhase());
                phaser.awaitAdvance(0);

                System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static class ThreadD implements Runnable {
        private Phaser phaser;

        public ThreadD(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

                Thread.sleep(5000);

                phaser.arriveAndAwaitAdvance();

                System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Phaser phaser = new Phaser(3);

        Thread t1 = new Thread(new ThreadA(phaser));
        Thread t2 = new Thread(new ThreadB(phaser));
        Thread t3 = new Thread(new ThreadC(phaser));
        Thread t4 = new Thread(new ThreadD(phaser));

        t1.setName("ThreadA");
        t2.setName("ThreadB");
        t3.setName("ThreadC");
        t4.setName("ThreadD");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

Run


Note:

awaitAdvance(int phase)并不参与parties计数的操作，仅仅具有判断的功能

 

更改ThreadC，将 

phaser.awaitAdvance(0);

改为

phaser.awaitAdvance(1);

再Run


Note:

由于传入参数phase值和当前getPhase()返回值不一致，则立即返回

 

awaitAdvanceInterruptibly(int phase)

awaitAdvanceInterruptibly(int phase)作用是传入参数phase值和当前getPhase()返回值不一致时，则继续执行下面的代码

PhaserTest14.java

package org.fool.java.concurrent.phaser;

import java.util.concurrent.Phaser;

public class PhaserTest14 {
    public static class ThreadA implements Runnable {
        private Phaser phaser;

        public ThreadA(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

                System.out.println("phaser.getPhase()=" + phaser.getPhase());
                phaser.awaitAdvanceInterruptibly(10);

                System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                System.out.println("InterruptedException invoked...");
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Phaser phaser = new Phaser(3);

        Thread t1 = new Thread(new ThreadA(phaser));
        t1.setName("ThreadA");
        t1.start();
    }
}

Run


Note:

由于传入参数phase值和当前getPhase()返回值不一致，控制台程序快速继续向下执行，运行的时间几乎是一样的

 

awaitAdvance(int phase)是不可中断的

PhaserTest12.java

package org.fool.java.concurrent.phaser;

import java.util.concurrent.Phaser;

public class PhaserTest12 {
    public static class ThreadA implements Runnable {
        private Phaser phaser;

        public ThreadA(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

            System.out.println("phaser.getPhase()=" + phaser.getPhase());
            phaser.awaitAdvance(0);

            System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        try {
            Phaser phaser = new Phaser(3);

            Thread t1 = new Thread(new ThreadA(phaser));
            t1.setName("ThreadA");
            t1.start();

            Thread.sleep(3000);

            t1.interrupt();

            System.out.println("interrupt() invoked..");
        } catch (InterruptedException e) {
            System.out.println("InterruptedException invoked...");
            e.printStackTrace();
        }
    }
}

Run


Note:

控制台没有出现异常，说明线程并未中断 

 

awaitAdvanceInterruptibly(int phase)是可中断的

PhaserTest13.java

package org.fool.java.concurrent.phaser;

import java.util.concurrent.Phaser;

public class PhaserTest13 {
    public static class ThreadA implements Runnable {
        private Phaser phaser;

        public ThreadA(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

                System.out.println("phaser.getPhase()=" + phaser.getPhase());
                phaser.awaitAdvanceInterruptibly(0);

                System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                System.out.println("InterruptedException invoked...");
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            Phaser phaser = new Phaser(3);

            Thread t1 = new Thread(new ThreadA(phaser));
            t1.setName("ThreadA");
            t1.start();

            Thread.sleep(5000);

            t1.interrupt();

            System.out.println("interrupt() invoked..");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Run


Note:

控制台出现异常，线程被中断了 

 

awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)

awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)作用是在指定的Phase等待最大的单位时间，如果在指定的时间内，Phase值未变，则出现异常，否则继续向下运行。


PhaserTest15.java

package org.fool.java.concurrent.phaser;

import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PhaserTest15 {
    public static class ThreadA implements Runnable {
        private Phaser phaser;

        public ThreadA(Phaser phaser) {
            this.phaser = phaser;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " A1 begin " + System.currentTimeMillis());

                System.out.println("phaser.getPhase()=" + phaser.getPhase());
                phaser.awaitAdvanceInterruptibly(0, 5, TimeUnit.SECONDS);

                System.out.println(Thread.currentThread().getName() + " A1 end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                System.out.println("InterruptedException invoked...");
                e.printStackTrace();
            } catch (TimeoutException e) {
                System.out.println("TimeoutException invoked...");
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Phaser phaser = new Phaser(3);

        Thread t1 = new Thread(new ThreadA(phaser));
        t1.setName("ThreadA");
        t1.start();
    }
}

Run  


Note:

出现了超时异常，因为5秒之后phase值并没有发生改变 

 

修改main方法

public static void main(String[] args) {
	try {
		Phaser phaser = new Phaser(3);

		Thread t1 = new Thread(new ThreadA(phaser));
		t1.setName("ThreadA");
		t1.start();

		System.out.println("phaser.getArrivedParties()=" + phaser.getArrivedParties());

		Thread.sleep(1000);
		phaser.arrive();
		System.out.println("phaser.getArrivedParties()=" + phaser.getArrivedParties());

		Thread.sleep(1000);
		phaser.arrive();
		System.out.println("phaser.getArrivedParties()=" + phaser.getArrivedParties());

		Thread.sleep(1000);
		phaser.arrive();
		System.out.println("phaser.getArrivedParties()=" + phaser.getArrivedParties());

		Thread.sleep(3000);
		System.out.println("phaser.getPhase()=" + phaser.getPhase());
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

再Run


Note：

5秒之后phase值发生改变，继续向下运行 

 

再次修改main方法

public static void main(String[] args) {
	try {
		Phaser phaser = new Phaser(3);

		Thread t1 = new Thread(new ThreadA(phaser));
		t1.setName("ThreadA");
		t1.start();

		Thread.sleep(1000);
		t1.interrupt();
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

再Run


Note:

提前将还未到达5秒的线程进行了中断 

 

Reference

Java并发编程核心方法与框架  

  

Agile牧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jodconverter-core-3.0-beta-4jar&sources&javadoc
12-03
3. **并发处理**：`org.jodconverter.concurrent`包提供了并发处理工具，允许在多线程环境中高效地执行大量转换任务。 4. **日志记录**：JodConverter集成了SLF4J（Simple Logging Facade for Java），方便开发者...
mastering-c-multithreading-write-robust-concurrent-and-parallel
11-25
mastering-c-multithreading-write-robust-concurrent-and-parallel-applications_compress
Java 并发编程学习笔记(11) ----Phaser-awaitAdvance(int phase),forceTermination(),isTerminated()
过河的小卒子的博客
06-01 862
51.awaitAdvance(int phase) 作用：如果传入参数Phase和当前getPhase()方法返回值一样，就在屏障处等待，否则继续向下运行。 52.代码 package com.lhc.concurrent.phaser.awaitAdvance; import java.util.concurrent.Phaser; public class ThreadA exte...
Concurrent - Phaser - arriveAndAwaitAdvance() & arriveAndDeregister()
jvisualvm
12-13 437
原创转载请注明出处：http://agilestyle.iteye.com/blog/2344591   Phaser提供了动态增减parties计数，这点比CyclicBarrier类操作parties更加方便，通过若干个方法来控制多个线程之间同步运行的结果，还可以实现针对某一个线程取消同步运行的效果，而且支持屏障处等待，在等待时还支持中断或非中断等功能，使用Java并发类对线程进行分组...
java并发包之Phaser的arriveAndAwaitAdvance方法用法实例
qq_30908729的博客
05-26 425
java并发包之Phaser的arriveAndAwaitAdvance方法用法实例演示，秒懂 解决方法： 1.线程类 package com.wlg; import java.util.concurrent.Phaser; public class MyThread extends Thread { public Phaser phaserser; public MyThread( Phaser phaserser) { this.phaser...
Java 并发编程（十六）：并发工具 Phaser
码客
01-27 446
1、概述 CountDownLatch 和 CyclicBarrier 都是JDK 1.5引入的，而 Phaser 是JDK 1.7引入的。Phaser的功能与CountDownLatch和CyclicBarrier有部分重叠，同时也提供了更丰富的语义和更灵活的用法。 CyclicBarrier，允许一组线程互相等待，直到到达某个公共屏障点。它提供的await()可以实现让所有参与者在临界点到来之...
Concurrent-开源
07-08
任务并行库建立在 Grand Central Dispatch 和 Parallel Patterns 之上。 包括任务依赖性管理、用于数据并行或缓存友好处理的项目分组，以及用于基于多核任务的编程的其他实用程序。
JavaEE源代码 concurrent-1.3.2
07-09
JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-1.3.2JavaEE源代码 concurrent-...
concurrent-1.3.4.jar
最新发布
05-21
concurrent-1.3.4 使用concurrent包可以实现以下功能： 并发控制：concurrent包提供了一些线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，可以在多线程环境下安全地对集合进行操作，而无需手动...
三.多线程JUC篇-3.13 Phaser工具
中国华的博客
11-16 88
前言 Phaser是JDK1.7提供的一种同步工具，是可重用的同步屏障，其功能类似于CyclicBarrier和CountDownLatch，但支持更灵活的用法。本篇主要讲解Phaser、Exchanger两种工具的用法。 其更加灵活的地方就在于：可以阶段性的控制各个线程的行为。 举个例子 总共六位同学要参加同学聚会，聚会流程有三项：吃饭、K歌、看电影。六位同学都要吃饭，但是吃完饭后只有四位同学想K歌，K完歌后只有两位同学想看电影。 实现这样的场景，用CyclicBarrier和CountDownLatch
Java并发包学习笔记
qq_48238787的博客
10-01 225
1、Semaphore与Exchanger的使用  1.1、Semphore的使用     Semaphore该类的主要作用就是限制线程的并发数量，它所提供的功能是Synchronized关键字的升级版，可以让线程同步（一个一个执行任务，而不是并行执行）来保证程序逻辑的正确性。  1.2、类Semaphore的常用API 构造函数的参数 int permits 它代表着同一时间内，最多允许多少个线程同时执行acquire()与release()之间的代码，无参方法acquire（）的作用是使用一个许可(p
死磕 java同步系列之Phaser源码解析
weixin_30555515的博客
10-01 206
问题 （1）Phaser是什么？ （2）Phaser具有哪些特性？ （3）Phaser相对于CyclicBarrier和CountDownLatch的优势？ 简介 Phaser，翻译为阶段，它适用于这样一种场景，一个大任务可以分为多个阶段完成，且每个阶段的任务可以多个线程并发执行，但是必须上一个阶段的任务都完成了才可以执行下一个阶段的任务。 这种场景虽然使用CyclicBarrier或者...
Java多线程之Phaser使用说明
我的博客
12-23 194
Java多线程之Phaser使用说明
java并发包笔记一
white_while的博客
09-04 221
文章目录java并发包笔记一Semaphore和ExchangerSemaphoreExchangerCountDownLatch和CyclicBarrierCountDownLatchCyclicBarrierPhaser**Executor与ThreadPoolExecutorExecutorExecutors工厂创建线程池newCachedThreadPoolnewFixedThreadPo...
Java高并发编程中Phaser的使用及详细介绍-刘宇
刘宇的博客
08-11 4547
作者：刘宇。一、什么是Phaser？二、Phaser的常用方法1、register方法2、bulkRegister方法3、getRegisteredParties方法4、arriveAndAwaitAdvance方法5、arriveAndDeregister方法6、arrive方法7、awaitAdvance方法8、awaitAdvanceInterruptibly方法9、getArrivedParties方法10、getUnarrivedParties方法11、isTerminated方法
Java7并发编程--3.4、Phaser并发阶段任务的运行
HelloWorld
08-11 2623
Phaser是一个更强大的、更复杂的同步辅助类，可以代替CyclicBarrier CountDownLatch的功能，但是比他们更强大。          Phaser类机制是在每一步结束的位置对线程进行同步，当所有的线程都完成了这一步，才能进行下一步。          当我们有并发任务并且需要分解成几步执行的时候，这种机制就非常适合。          CyclicBarrier Co
phaser 使用
renguiriyue的博客
04-04 255
摘抄： https://www.jianshu.com/p/1517a379fb91 可参考： https://www.iteye.com/blog/shift-alt-ctrl-2302923 常用方法 1，设定任务数（这是官方解释，简单的讲比如我们指定任务数为3，那3个线程都运行到指定地方他们才会分别继续往下执行） \\批量设置任务数 public int bulkRegister(int p...
第三章线程同步辅助类
https://github.com/Wang-Jun-Chao
09-01 2178
Java 7 并发编程实战手册目录代码下载(https://github.com/Wang-Jun-Chao/java-concurrency)第三章线程同步辅助类3.1简介　　♦信号量（Semaphore):是一种计数器，用来保护一个或者多个共享资源的访问。它是并发编程的一种基础工具，大多数编程语言都提供了这个机制。　　♦ CountDownLatch:是Java语言提供的同步辅助类，在完成一组正
concurrent assignment to a non-net
04-03
In Verilog, a non-net refers to a variable that is not a wire or a register, but rather a constant or a parameter. Concurrent assignment refers to the assignment of a value to a variable using the "=" operator in a module outside of any procedural blocks (such as always or initial blocks). A concurrent assignment to a non-net is not allowed in Verilog. This is because a non-net does not have a storage element and cannot hold a value assigned to it. Instead, it is typically used as a constant or a parameter that is available for use in the module. To assign a value to a non-net, it should be done within a procedural block using the appropriate assignment operator (such as "<=" for registers or "assign" for wires). Alternatively, the value can be passed as an argument to the module using the parameter keyword. For example: module my_module #(parameter WIDTH = 8) ( input clk, input [WIDTH-1:0] data_in, output [WIDTH-1:0] data_out ); // This is a non-net parameter parameter ADD_VALUE = 5; // This is a register that can be assigned using the "=" operator within an always block reg [WIDTH-1:0] register_data; always @(posedge clk) begin register_data <= data_in + ADD_VALUE; end // This is a wire that can be assigned using the "assign" keyword assign data_out = register_data; endmodule In this example, ADD_VALUE is a non-net parameter that is used in the always block to add a constant value to the input data. The register_data variable is assigned using the "=" operator within the always block. The data_out wire is assigned using the "assign" keyword.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值