FilesExpand file tree

 master

/

SemaphoreDemo.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

68 lines (66 loc) · 2.03 KB

 master

/

SemaphoreDemo.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

68 lines (66 loc) · 2.03 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

//: concurrency/SemaphoreDemo.java

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

// Testing the Pool class

import java.util.concurrent.*;

import java.util.*;

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

// A task to check a resource out of a pool:

class CheckoutTask<T> implements Runnable {

private static int counter = 0;

private final int id = counter++;

private Pool<T> pool;

public CheckoutTask(Pool<T> pool) {

this.pool = pool;

}

public void run() {

try {

T item = pool.checkOut();

print(this + "checked out " + item);

TimeUnit.SECONDS.sleep(1);

print(this +"checking in " + item);

pool.checkIn(item);

} catch(InterruptedException e) {

// Acceptable way to terminate

}

}

public String toString() {

return "CheckoutTask " + id + " ";

}

}

public class SemaphoreDemo {

final static int SIZE = 25;

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

final Pool<Fat> pool =

new Pool<Fat>(Fat.class, SIZE);

ExecutorService exec = Executors.newCachedThreadPool();

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

exec.execute(new CheckoutTask<Fat>(pool));

print("All CheckoutTasks created");

List<Fat> list = new ArrayList<Fat>();

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

Fat f = pool.checkOut();

printnb(i + ": main() thread checked out ");

f.operation();

list.add(f);

}

Future<?> blocked = exec.submit(new Runnable() {

public void run() {

try {

// Semaphore prevents additional checkout,

// so call is blocked:

pool.checkOut();

} catch(InterruptedException e) {

print("checkOut() Interrupted");

}

}

});

TimeUnit.SECONDS.sleep(2);

blocked.cancel(true); // Break out of blocked call

print("Checking in objects in " + list);

for(Fat f : list)

pool.checkIn(f);

for(Fat f : list)

pool.checkIn(f); // Second checkIn ignored

exec.shutdown();

}

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