FilesExpand file tree

 master

/

OrnamentalGarden.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

103 lines (100 loc) · 2.81 KB

 master

/

OrnamentalGarden.java

Copy path

Top

File metadata and controls

• Code
• Blame

103 lines (100 loc) · 2.81 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

//: concurrency/OrnamentalGarden.java

import java.util.concurrent.*;

import java.util.*;

import static net.mindview.util.Print.*;

class Count {

private int count = 0;

private Random rand = new Random(47);

// Remove the synchronized keyword to see counting fail:

public synchronized int increment() {

int temp = count;

if(rand.nextBoolean()) // Yield half the time

Thread.yield();

return (count = ++temp);

}

public synchronized int value() { return count; }

}

class Entrance implements Runnable {

private static Count count = new Count();

private static List<Entrance> entrances =

new ArrayList<Entrance>();

private int number = 0;

// Doesn't need synchronization to read:

private final int id;

private static volatile boolean canceled = false;

// Atomic operation on a volatile field:

public static void cancel() { canceled = true; }

public Entrance(int id) {

this.id = id;

// Keep this task in a list. Also prevents

// garbage collection of dead tasks:

entrances.add(this);

}

public void run() {

while(!canceled) {

synchronized(this) {

++number;

}

print(this + " Total: " + count.increment());

try {

TimeUnit.MILLISECONDS.sleep(100);

} catch(InterruptedException e) {

print("sleep interrupted");

}

}

print("Stopping " + this);

}

public synchronized int getValue() { return number; }

public String toString() {

return "Entrance " + id + ": " + getValue();

}

public static int getTotalCount() {

return count.value();

}

public static int sumEntrances() {

int sum = 0;

for(Entrance entrance : entrances)

sum += entrance.getValue();

return sum;

}

}

public class OrnamentalGarden {

public static void main(String[] args) throws Exception {

ExecutorService exec = Executors.newCachedThreadPool();

for(int i = 0; i < 5; i++)

exec.execute(new Entrance(i));

// Run for a while, then stop and collect the data:

TimeUnit.SECONDS.sleep(3);

Entrance.cancel();

exec.shutdown();

if(!exec.awaitTermination(250, TimeUnit.MILLISECONDS))

print("Some tasks were not terminated!");

print("Total: " + Entrance.getTotalCount());

print("Sum of Entrances: " + Entrance.sumEntrances());

}

} /* Output: (Sample)

Entrance 0: 1 Total: 1

Entrance 2: 1 Total: 3

Entrance 1: 1 Total: 2

Entrance 4: 1 Total: 5

Entrance 3: 1 Total: 4

Entrance 2: 2 Total: 6

Entrance 4: 2 Total: 7

Entrance 0: 2 Total: 8

...

Entrance 3: 29 Total: 143

Entrance 0: 29 Total: 144

Entrance 4: 29 Total: 145

Entrance 2: 30 Total: 147

Entrance 1: 30 Total: 146

Entrance 0: 30 Total: 149

Entrance 3: 30 Total: 148

Entrance 4: 30 Total: 150

Stopping Entrance 2: 30

Stopping Entrance 1: 30

Stopping Entrance 0: 30

Stopping Entrance 3: 30

Stopping Entrance 4: 30

Total: 150

Sum of Entrances: 150

*///:~