java phaser用法_Java并发编程核心方法与框架-phaser的使用

最新推荐文章于 2021-10-05 22:53:29 发布
最新推荐文章于 2021-10-05 22:53:29 发布
阅读量169 收藏
点赞数
文章标签： java phaser用法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31082779/article/details/114202988
版权

arriveAndAwaitAdvance()方法

arriveAndAwaitAdvance()作用是当前线程已经到达屏障，在此等待一段时间，等条件满足后继续向下一个屏障执行。

public class PrintTools {

public static Phaser phaser;

public static void methodA() {

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

phaser.arriveAndAwaitAdvance();

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

System.out.println(Thread.currentThread().getName() + " A2 begin " + System.currentTimeMillis());

phaser.arriveAndAwaitAdvance();

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

}

public static void methodB() {

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());

System.out.println(Thread.currentThread().getName() + " A2 begin " + System.currentTimeMillis());

Thread.sleep(5000);

phaser.arriveAndAwaitAdvance();

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

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public class ThreadA extends Thread {

@Override

public void run() {

PrintTools.methodA();//执行A方法

}

}

public class ThreadB extends Thread {

@Override

public void run() {

PrintTools.methodA();//执行A方法

}

}

public class ThreadC extends Thread {

@Override

public void run() {

PrintTools.methodB();//执行B方法

}

}

public class Main {

public static void main(String[] args) {

Phaser phaser = new Phaser(3);

PrintTools.phaser = phaser;

ThreadA a = new ThreadA();

a.setName("A");

a.start();

ThreadB b = new ThreadB();

b.setName("B");

b.start();

ThreadC c = new ThreadC();

c.setName("C");

c.start();

}

}

程序运行结果如下：

A A1 begin 1469711023742

B A1 begin 1469711023742

C A1 begin 1469711023743

C A1 end 1469711028745

A A1 end 1469711028745

B A1 end 1469711028745

A A2 begin 1469711028745

C A2 begin 1469711028745

B A2 begin 1469711028745

B A2 end 1469711033748

C A2 end 1469711033748

A A2 end 1469711033748

A、B线程会等待C线程一起到达屏障点，然后一起继续向下执行。

对以上代码做如下修改：

public class PrintTools {

public static Phaser phaser;

public static void methodA() {

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

phaser.arriveAndAwaitAdvance();

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

System.out.println(Thread.currentThread().getName() + " A2 begin " + System.currentTimeMillis());

phaser.arriveAndAwaitAdvance();

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

}

public static void methodB() {

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());

/* C提前退出比赛

System.out.println(Thread.currentThread().getName() + " A2 begin " + System.currentTimeMillis());

Thread.sleep(5000);

phaser.arriveAndAwaitAdvance();

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

*/

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//其他代码保持不变

重新运行程序，控制台打印结果如下：

A A1 begin 1469711274416

B A1 begin 1469711274416

C A1 begin 1469711274417

B A1 end 1469711279421

C A1 end 1469711279421

A A1 end 1469711279421

B A2 begin 1469711279421

A A2 begin 1469711279421

A、B到达第二个屏障点后等不到C的到来，程序不结束，将会一直等下去。

arriveAndDeregister()方法

arriveAndDeregister()方法的作用是使线程退出比赛，并且使parties值减1

对以上代码做如下修改：

public class PrintTools {

public static Phaser phaser;

public static void methodA() {

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

phaser.arriveAndAwaitAdvance();

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

System.out.println(Thread.currentThread().getName() + " A2 begin " + System.currentTimeMillis());

phaser.arriveAndAwaitAdvance();

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

}

public static void methodB() {

try {

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

Thread.sleep(5000);

System.out.println("A:" + phaser.getRegisteredParties());

phaser.arriveAndDeregister();//退出比赛

System.out.println("B:" + phaser.getRegisteredParties());

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

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//其他代码保持不变

程序运行结果如下：

A A1 begin 1469711921794

B A1 begin 1469711921795

C A1 begin 1469711921795

A:3

B:2

B A1 end 1469711926799

C A1 end 1469711926799

A A1 end 1469711926799

B A2 begin 1469711926799

A A2 begin 1469711926800

B A2 end 1469711926800

A A2 end 1469711926800

此时程序可以正常结束。

onAdvance()方法

public class MyService {

private Phaser phaser;

public MyService(Phaser phaser) {

super();

this.phaser = phaser;

}

public void testMethod() {

try {

System.out.println("阶段1 Begin " + Thread.currentThread().getName() + System.currentTimeMillis());

if (Thread.currentThread().getName().equals("B")) {

Thread.sleep(5000);

}

phaser.arriveAndAwaitAdvance();

System.out.println("阶段1 End " + Thread.currentThread().getName() + " end phase value=" + phaser.getPhase() + " " + System.currentTimeMillis());

/********/

System.out.println("阶段2 Begin " + Thread.currentThread().getName() + System.currentTimeMillis());

if (Thread.currentThread().getName().equals("B")) {

Thread.sleep(5000);

}

phaser.arriveAndAwaitAdvance();

System.out.println("阶段2 End " + Thread.currentThread().getName() + " end phase value=" + phaser.getPhase() + " " + System.currentTimeMillis());

/********/

System.out.println("阶段3 Begin " + Thread.currentThread().getName() + System.currentTimeMillis());

if (Thread.currentThread().getName().equals("B")) {

Thread.sleep(5000);

}

phaser.arriveAndAwaitAdvance();

System.out.println("阶段3 End " + Thread.currentThread().getName() + " end phase value=" + phaser.getPhase() + " " + System.currentTimeMillis());

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

//省略ThreadA、ThreadB

public class Main {

public static void main(String[] args) {

Phaser phaser = new Phaser(2){

@Override

protected boolean onAdvance(int phase, int registeredParties) {

System.out.println("onAdvance 被" + Thread.currentThread().getName() + "调用 " + System.currentTimeMillis() + " phase value=" + phase + " registeredParties=" + registeredParties);

return false;

//返回true 不等待，Phaser呈无效/销毁的状态

//返回false则Phaser继续工作

}

};

MyService service = new MyService(phaser);

ThreadA a = new ThreadA(service);

a.setName("A");

a.start();

ThreadB b = new ThreadB(service);

b.setName("B");

b.start();

}

}

运行程序，控制台打印结果如下：

阶段1 Begin A1470103011668

阶段1 Begin B1470103011669

onAdvance 被B调用 1470103016670 phase value=0 registeredParties=2

阶段1 End B end phase value=1 1470103016670

阶段1 End A end phase value=1 1470103016670

阶段2 Begin A1470103016670

阶段2 Begin B1470103016670

onAdvance 被B调用 1470103021675 phase value=1 registeredParties=2

阶段2 End B end phase value=2 1470103021675

阶段2 End A end phase value=2 1470103021675

阶段3 Begin A1470103021675

阶段3 Begin B1470103021675

onAdvance 被B调用 1470103026677 phase value=2 registeredParties=2

阶段3 End B end phase value=3 1470103026677

阶段3 End A end phase value=3 1470103026677

onAdvance()在B线程到达屏障点时被调用。如果在onAdvance()方法中返回true，Phaser会被销毁。

对main函数中的代码做如下修改：

public class Main {

public static void main(String[] args) {

Phaser phaser = new Phaser(2){

@Override

protected boolean onAdvance(int phase, int registeredParties) {

System.out.println("onAdvance 被" + Thread.currentThread().getName() + "调用 " + System.currentTimeMillis() + " phase value=" + phase + " registeredParties=" + registeredParties);

return true;

//返回true 不等待，Phaser呈无效/销毁的状态

//返回false则Phaser继续工作

}

};

MyService service = new MyService(phaser);

ThreadA a = new ThreadA(service);

a.setName("A");

a.start();

ThreadB b = new ThreadB(service);

b.setName("B");

b.start();

}

}

重新运行程序，控制台打印结果如下：

阶段1 Begin A1470103416899

阶段1 Begin B1470103416899

onAdvance 被B调用 1470103421901 phase value=0 registeredParties=2

阶段1 End B end phase value=-2147483647 1470103421901

阶段1 End A end phase value=-2147483647 1470103421901

阶段2 Begin B1470103421901

阶段2 Begin A1470103421901

阶段2 End A end phase value=-2147483647 1470103421901

阶段3 Begin A1470103421901

阶段3 End A end phase value=-2147483647 1470103421902

阶段2 End B end phase value=-2147483647 1470103426905

阶段3 Begin B1470103426905

阶段3 End B end phase value=-2147483647 1470103431907

arrive()方法

arrive()方法的作用是使parties值加1，并且不在屏障处等待，直接向下面的代码继续运行，并且充值Phaser类的计数。

public class Run {

public static void main(String[] args) {

Phaser phaser = new Phaser(2){

@Override

protected boolean onAdvance(int phase, int registeredParties) {

System.out.println("到达了未通过！phase=" + phase + " registeredParties=" + registeredParties);

return super.onAdvance(phase, registeredParties);

}

};

System.out.println("A1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("A1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

System.out.println("A2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("A2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

//---------

System.out.println("B1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("B1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

System.out.println("B2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("B2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

//---------

System.out.println("C1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("C1，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

System.out.println("C2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

phaser.arrive();

System.out.println("C2，getPhase=" + phaser.getPhase() + " getRegisteredParties=" + phaser.getRegisteredParties() + " getArrivedParties=" + phaser.getArrivedParties());

}

}

运行程序，控制台打印结果如下：

A1，getPhase=0 getRegisteredParties=2 getArrivedParties=0

A1，getPhase=0 getRegisteredParties=2 getArrivedParties=1

A2，getPhase=0 getRegisteredParties=2 getArrivedParties=1

到达了未通过！phase=0 registeredParties=2

A2，getPhase=1 getRegisteredParties=2 getArrivedParties=0

B1，getPhase=1 getRegisteredParties=2 getArrivedParties=0

B1，getPhase=1 getRegisteredParties=2 getArrivedParties=1

B2，getPhase=1 getRegisteredParties=2 getArrivedParties=1

到达了未通过！phase=1 registeredParties=2

B2，getPhase=2 getRegisteredParties=2 getArrivedParties=0

C1，getPhase=2 getRegisteredParties=2 getArrivedParties=0

C1，getPhase=2 getRegisteredParties=2 getArrivedParties=1

C2，getPhase=2 getRegisteredParties=2 getArrivedParties=1

到达了未通过！phase=2 registeredParties=2

C2，getPhase=3 getRegisteredParties=2 getArrivedParties=0

方法arrive()的功能是使getArrivedParties()计数加1，不等待其他线程到达屏障。控制台多次出现getArrivedParties=0说明Phaser类经过屏障点后计数被重置。

arriveAdvance(int phase)方法的作用是：如果传入参数phase值和当前getPhase()方法返回值一样，则在屏障处等待，否则继续向下面运行。

public class ThreadA extends Thread {

private Phaser phaser;

public ThreadA(Phaser phaser) {

super();

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 class ThreadB extends Thread {

private Phaser phaser;

public ThreadB(Phaser phaser) {

super();

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 class ThreadC extends Thread {

private Phaser phaser;

public ThreadC(Phaser phaser) {

super();

this.phaser = phaser;

}

@Override

public void run() {

try {

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

Thread.sleep(3000);

phaser.awaitAdvance(0);//跨栏的栏数。不参与parties计数的操作，仅具有判断功能。

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

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public class ThreadD extends Thread {

private Phaser phaser;

public ThreadD(Phaser phaser) {

super();

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 class Main {

public static void main(String[] args) {

Phaser phaser = new Phaser(3);

ThreadA a = new ThreadA(phaser);

a.setName("A");

a.start();

ThreadB b = new ThreadB(phaser);

b.setName("B");

b.start();

ThreadC c = new ThreadC(phaser);

c.setName("C");

c.start();

ThreadD d = new ThreadD(phaser);

d.setName("D");

d.start();

}

}

程序运行结果如下：

A A1 begin 1470226617412

B A1 begin 1470226617412

C A1 begin 1470226617413

D A1 begin 1470226617414

C A1 end 1470226622416

B A1 end 1470226622416

A A1 end 1470226622416

D A1 end 1470226622416

K8S技术社区
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程之Phaser的使用详解
08-19
主要介绍了java多线程之Phaser的使用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java phaser用法_java多线程之Phaser的使用详解
weixin_39640372的博客
02-13 223
前面的文章中我们讲到了CyclicBarrier、CountDownLatch的使用，这里再回顾一下CountDownLatch主要用在一个线程等待多个线程执行完毕的情况，而CyclicBarrier用在多个线程互相等待执行完毕的情况。Phaser是java 7 引入的新的并发API。他引入了新的Phaser的概念，我们可以将其看成一个一个的阶段，每个阶段都有需要执行的线程任务，任务执行完毕就进入...
Java 7 同步组件Phaser
Java&&大数据专栏
09-16 1212
Java 7的并发包中推出了Phaser，其功能跟CyclicBarrier和CountDownLatch有些重叠，但是提供了更灵活的用法，例如支持动态调整注册任务的数量等。本文在Phaser自带的示例代码基础上进行一下简单的分析。 注册(Registration)     Phaser支持通过register()和bulkRegister(int parties)方法来动态调整注册任务的数量
java并发编程-Phaser的使用
zg_hover的专栏
03-03 463
Phaser介绍 在生活中我们会遇到这样的场景：我们把一个任务分成多个阶段来做，每个阶段可以由多人来做，当一个阶段所有人的任务都完成后，才能进入下一个阶段，按这样的方式来完成任务直到任务完成。 类似于一个阶段性事务。那么在java编程中如何实现呢？可以通过并发包中的Phaser来模拟实现该场景。 Java中的Phaser也是一个同步barrier（屏障），就像CountDownLatch和CyclicBarrier一样，线程需要在barrier处等待，直到所有线程都达到barrier，也就是barrier被
java Phaser
Code-lover's Learning Notes
05-07 1180
1 OverviewJava 7的并发包中推出了Phaser，其功能跟CyclicBarrier和CountDownLatch有些重叠，但是提供了更灵活的用法，例如支持动态调整注册任务的数量等。本文在Phaser自带的示例代码基础上进行一下简单的分析。2 Glossary2.1 RegistrationPhaser支持通过register()和bulkRegister(int parties)方法来
java-concurrency编程内部分享_java实战_java_
10-02
Doug Lea在书中详细介绍了Java并发编程的核心概念，包括线程安全、竞态条件、死锁、活锁、饥饿以及如何避免这些问题。他引入了`java.util.concurrent`包，这个包中包含了许多高级并发工具，如`Semaphore`（信号量）...
java并发编程艺术源码-ArtConcurrentBook:JAVA并发编程的艺术
05-25
《Java并发编程艺术》是一本深入探讨Java多线程与并发编程的经典著作，它涵盖了Java并发编程的基础到高级主题，旨在帮助开发者掌握在Java平台上进行高效并发编程的技术和最佳实践。源码ArtConcurrentBook提供了书中...
Java多线程编程实战指南-核心篇
06-10
《Java多线程编程实战指南-核心篇》是一本深入探讨Java并发编程的书籍，旨在帮助读者掌握在Java环境中创建、管理和同步线程的核心技术。Java的多线程能力是其强大之处，使得开发者能够在同一时间执行多个任务，提高...
J7CC:Examples in Java 7 Concurrency Cookbook, Java 7 并发编程实战手册
06-05
《Java 7 Concurrency Cookbook》是一本专注于Java并发编程实践的书籍，其示例代码集存放在名为"J7CC-master"的压缩包中。在Java 7中，并发编程得到了显著的提升，引入了许多新的特性和工具，使得开发者能够更高效、...
JAVA并发编程实践
10-31
根据给定文件的信息“JAVA并发编程实践”以及其描述为“Java并发学习资料”，我们可以从中提炼出关于Java并发编程的一些核心知识点。Java并发编程是Java高级特性之一，它允许开发者编写能够同时执行多个任务的程序，...
java phaser用法,通过示例了解java中的phaser
weixin_39783771的博客
02-16 132
I am trying to understand Phaser in java. I wrote an example which is stuck at advance waiting for other parties to arrive.As far as I understand, phaser is used as a reusable thread synchronization (...
Java高并发编程中Phaser的使用及详细介绍-刘宇
刘宇的博客
08-11 4620
作者：刘宇。一、什么是Phaser？二、Phaser的常用方法1、register方法2、bulkRegister方法3、getRegisteredParties方法4、arriveAndAwaitAdvance方法5、arriveAndDeregister方法6、arrive方法7、awaitAdvance方法8、awaitAdvanceInterruptibly方法9、getArrivedParties方法10、getUnarrivedParties方法11、isTerminated方法
java phaser用法_Java线程之Phaser
weixin_36308543的博客
02-24 182
Phaser是一个灵活的线程同步工具，他包含了CyclicBarrier和CountDownLatch的相关功能首先，来看一下如何用Phaser替代CountDownLatch。对于CountDownLatch而言，有2个重要的方法，一个是await()方法，可以使线程进入等待状态，在Phaser中，与之对应的方法是awaitAdvance(int n)。CountDownLatch中另一个重要的...
Java并发编程-同步辅助类之Phaser
记忆力不好的博客
06-07 2875
在前面已经学习过 Java并发编程-同步辅助类之CountDownLatch Java并发编程-同步辅助类之CyclicBarrier 这篇文章介绍另一个辅助类Phaser，它是J在Dk 1.7才添加的新的功能，它可以实现和CountDownLatch/CyclicBarrier类似的功能，但Phaser的功能更多，更加的灵活，它支持任务在多个点都进行同步，支持动态调整注册任务的数量。当然你也
Java线程之Phaser
热门推荐
华丽的痘痘
04-23 1万+
Phaser是一个灵活的线程同步工具，他包含了CyclicBarrier和CountDownLatch的相关功能        首先，来看一下如何用Phaser替代CountDownLatch。对于CountDownLatch而言，有2个重要的方法，一个是await()方法，可以使线程进入等待状态，在Phaser中，与之对应的方法是awaitAdvance(int n)。CountDownL
Java多线程之----Phaser
菜鸟一名
12-17 699
Phaser类的功能和CyclicBarrier、CountDownLatch的有很多类似的地方，例如线程互相等待，等待某个线程完成再进行其他任务，这在Phaser都可以实现，而Phaser却更加的灵活，因为它可以动态的注册线程数量，取消注册数量，这可以给我们带来更多的控制。     Phaser有几个重要的方法：         1.arrive:该方法简单的说就是记录到达的线程数，有点像C
Phaser用法
蓝斌星的博客
10-05 119
https://www.cnblogs.com/chenssy/p/4989515.html
【Java并发编程实战】—–“J.U.C”：Phaser
chenssy 的技术博客
11-23 3680
Phaser由java7中推出，是Java SE 7中新增的一个使用同步工具，在功能上面它与CyclicBarrier、CountDownLatch有些重叠，但是它提供了更加灵活、强大的用法。CyclicBarrier，允许一组线程互相等待，直到到达某个公共屏障点。它提供的await()可以实现让所有参与者在临界点到来之前一直处于等待状态。CountDownLatch，在完成一组正在其他线程中执行
java phaser用法_第3章Phaser的使用-（java并发编程核心方法与框架）
weixin_28900073的博客
02-16 84
3.1 Phaser的使用3.2 类Phaser的arriveAndAwaitAdvance()方法测试13.3 类Phaser的arriveAndAwaitAdvance()方法测试23.4 类Phaser的arriveAndDeregister()方法测试3.5 类Phaser的getPhase()和onAdvance()方法测试3.6 类Phaser的getRegisteredParties...
Java执行器框架：简化并发编程与机器学习示例
"执行器简介是Java并发编程中的一个重要概念，尤其是在Java 5引入的执行器框架中。该框架提供了相较于早期实现方式更为高效且易于使用的并发处理机制，旨在解决线程过多导致性能下降和系统稳定性问题。执行器的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值