FilesExpand file tree

 master

/

HorseRace.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

88 lines (86 loc) · 2.69 KB

 master

/

HorseRace.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

88 lines (86 loc) · 2.69 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

//: concurrency/HorseRace.java

package concurrency; /* Added by Eclipse.py */

// Using CyclicBarriers.

import java.util.concurrent.*;

import java.util.*;

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

class Horse implements Runnable {

private static int counter = 0;

private final int id = counter++;

private int strides = 0;

private static Random rand = new Random(47);

private static CyclicBarrier barrier;

public Horse(CyclicBarrier b) { barrier = b; }

public synchronized int getStrides() { return strides; }

public void run() {

try {

while(!Thread.interrupted()) {

synchronized(this) {

strides += rand.nextInt(3); // Produces 0, 1 or 2

}

barrier.await();

}

} catch(InterruptedException e) {

// A legitimate way to exit

} catch(BrokenBarrierException e) {

// This one we want to know about

throw new RuntimeException(e);

}

}

public String toString() { return "Horse " + id + " "; }

public String tracks() {

StringBuilder s = new StringBuilder();

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

s.append("*");

s.append(id);

return s.toString();

}

}

public class HorseRace {

static final int FINISH_LINE = 75;

private List<Horse> horses = new ArrayList<Horse>();

private ExecutorService exec =

Executors.newCachedThreadPool();

private CyclicBarrier barrier;

public HorseRace(int nHorses, final int pause) {

barrier = new CyclicBarrier(nHorses, new Runnable() {

public void run() {

StringBuilder s = new StringBuilder();

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

s.append("="); // The fence on the racetrack

print(s);

for(Horse horse : horses)

print(horse.tracks());

for(Horse horse : horses)

if(horse.getStrides() >= FINISH_LINE) {

print(horse + "won!");

exec.shutdownNow();

return;

}

try {

TimeUnit.MILLISECONDS.sleep(pause);

} catch(InterruptedException e) {

print("barrier-action sleep interrupted");

}

}

});

for(int i = 0; i < nHorses; i++) {

Horse horse = new Horse(barrier);

horses.add(horse);

exec.execute(horse);

}

}

public static void main(String[] args) {

int nHorses = 7;

int pause = 200;

if(args.length > 0) { // Optional argument

int n = new Integer(args[0]);

nHorses = n > 0 ? n : nHorses;

}

if(args.length > 1) { // Optional argument

int p = new Integer(args[1]);

pause = p > -1 ? p : pause;

}

new HorseRace(nHorses, pause);

}

} /* (Execute to see output) *///:~