FilesExpand file tree

 master

/

ListComparisons.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

86 lines (82 loc) · 2.72 KB

 master

/

ListComparisons.java

Copy path

Top

File metadata and controls

• Code
• Blame

86 lines (82 loc) · 2.72 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

//: concurrency/ListComparisons.java

// {Args: 1 10 10} (Fast verification check during build)

// Rough comparison of thread-safe List performance.

import java.util.concurrent.*;

import java.util.*;

import net.mindview.util.*;

abstract class ListTest extends Tester<List<Integer>> {

ListTest(String testId, int nReaders, int nWriters) {

super(testId, nReaders, nWriters);

}

class Reader extends TestTask {

long result = 0;

void test() {

for(long i = 0; i < testCycles; i++)

for(int index = 0; index < containerSize; index++)

result += testContainer.get(index);

}

void putResults() {

readResult += result;

readTime += duration;

}

}

class Writer extends TestTask {

void test() {

for(long i = 0; i < testCycles; i++)

for(int index = 0; index < containerSize; index++)

testContainer.set(index, writeData[index]);

}

void putResults() {

writeTime += duration;

}

}

void startReadersAndWriters() {

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

exec.execute(new Reader());

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

exec.execute(new Writer());

}

}

class SynchronizedArrayListTest extends ListTest {

List<Integer> containerInitializer() {

return Collections.synchronizedList(

new ArrayList<Integer>(

new CountingIntegerList(containerSize)));

}

SynchronizedArrayListTest(int nReaders, int nWriters) {

super("Synched ArrayList", nReaders, nWriters);

}

}

class CopyOnWriteArrayListTest extends ListTest {

List<Integer> containerInitializer() {

return new CopyOnWriteArrayList<Integer>(

new CountingIntegerList(containerSize));

}

CopyOnWriteArrayListTest(int nReaders, int nWriters) {

super("CopyOnWriteArrayList", nReaders, nWriters);

}

}

public class ListComparisons {

public static void main(String[] args) {

Tester.initMain(args);

new SynchronizedArrayListTest(10, 0);

new SynchronizedArrayListTest(9, 1);

new SynchronizedArrayListTest(5, 5);

new CopyOnWriteArrayListTest(10, 0);

new CopyOnWriteArrayListTest(9, 1);

new CopyOnWriteArrayListTest(5, 5);

Tester.exec.shutdown();

}

} /* Output: (Sample)

Type Read time Write time

Synched ArrayList 10r 0w 232158294700 0

Synched ArrayList 9r 1w 198947618203 24918613399

readTime + writeTime = 223866231602

Synched ArrayList 5r 5w 117367305062 132176613508

readTime + writeTime = 249543918570

CopyOnWriteArrayList 10r 0w 758386889 0

CopyOnWriteArrayList 9r 1w 741305671 136145237

readTime + writeTime = 877450908

CopyOnWriteArrayList 5r 5w 212763075 67967464300

readTime + writeTime = 68180227375

*///:~