FilesExpand file tree

 master

/

DualCompletableOperations.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

115 lines (107 loc) · 2.48 KB

 master

/

DualCompletableOperations.java

Copy path

Top

File metadata and controls

• Code
• Blame

115 lines (107 loc) · 2.48 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

// concurrent/DualCompletableOperations.java

// (c)2017 MindView LLC: see Copyright.txt

// We make no guarantees that this code is fit for any purpose.

// Visit http://OnJava8.com for more book information.

import java.util.concurrent.*;

import static onjava.CompletableUtilities.*;

public class DualCompletableOperations {

static CompletableFuture<Workable> cfA, cfB;

static void init() {

cfA = Workable.make("A", 0.15);

cfB = Workable.make("B", 0.10); // Always wins

}

static void join() {

cfA.join();

cfB.join();

System.out.println("*****************");

}

public static void main(String[] args) {

init();

voidr(cfA.runAfterEitherAsync(cfB, () ->

System.out.println("runAfterEither")));

join();

init();

voidr(cfA.runAfterBothAsync(cfB, () ->

System.out.println("runAfterBoth")));

join();

init();

showr(cfA.applyToEitherAsync(cfB, w -> {

System.out.println("applyToEither: " + w);

return w;

}));

join();

init();

voidr(cfA.acceptEitherAsync(cfB, w -> {

System.out.println("acceptEither: " + w);

}));

join();

init();

voidr(cfA.thenAcceptBothAsync(cfB, (w1, w2) -> {

System.out.println("thenAcceptBoth: "

+ w1 + ", " + w2);

}));

join();

init();

showr(cfA.thenCombineAsync(cfB, (w1, w2) -> {

System.out.println("thenCombine: "

+ w1 + ", " + w2);

return w1;

}));

join();

init();

CompletableFuture<Workable>

cfC = Workable.make("C", 0.08),

cfD = Workable.make("D", 0.09);

CompletableFuture.anyOf(cfA, cfB, cfC, cfD)

.thenRunAsync(() ->

System.out.println("anyOf"));

join();

init();

cfC = Workable.make("C", 0.08);

cfD = Workable.make("D", 0.09);

CompletableFuture.allOf(cfA, cfB, cfC, cfD)

.thenRunAsync(() ->

System.out.println("allOf"));

join();

}

}

/* Output:

Workable[BW]

runAfterEither

Workable[AW]

*****************

Workable[BW]

Workable[AW]

runAfterBoth

*****************

Workable[BW]

applyToEither: Workable[BW]

Workable[BW]

Workable[AW]

*****************

Workable[BW]

acceptEither: Workable[BW]

Workable[AW]

*****************

Workable[BW]

Workable[AW]

thenAcceptBoth: Workable[AW], Workable[BW]

*****************

Workable[BW]

Workable[AW]

thenCombine: Workable[AW], Workable[BW]

Workable[AW]

*****************

Workable[CW]

anyOf

Workable[DW]

Workable[BW]

Workable[AW]

*****************

Workable[CW]

Workable[DW]

Workable[BW]

Workable[AW]

*****************

allOf

*/