Java 集合与队列的插入、删除在并发下的性能比较

这两天在写一个java多线程的爬虫，以广度优先爬取网页，设置两个缓存：

•　　一个保存已经访问过的URL：vistedUrls

•　　一个保存没有访问过的URL：unVistedUrls
　　需要爬取的数据量不大，对URL压缩后，可以把这两个数据结构都放入内存，vistedUrls很显然用HashSet<String>实现，因为已经访问的URL只会添加，不会删除和修改，使用HashSet可以高效判断一个URL是否已经访问。
　　纠结unVistedUrls该用什么数据结构，如果用队列的话，并发情况下，队列中可能会用重复的URL，比如一个线程A爬了CSDN的一个URL1，另一个线程B爬了博客园的一个URL2，URL1和URL2的页面都有一个相同的出链URL3，线程A把URL3加入到unVistedUrls的队尾，等待下次爬取，但在URL3被爬取之前，线程B也把URL3加到队尾，这样队列中就有两个相同的URL，可能会导致重复爬取网页，当然可以通过其他方法来保证不会重复爬取。
　　然后就想能否也用Set来保存未访问的URL，这样在添加新的URL时，自动去重处理了，能够有效保证不爬取重复网页。但是unVistedUrls会有大量的插入和删除操作，我认为对集合进行大量的插入删除性能会比较低，为了测试集合的插入删除性能对比队列低多少，我写了一个简单的并发测试：

复制代码

1 /**

2 * 测试集合与队列的插入与读写性能

3 *

4 * @author jiqunpeng@Gmail.com

5 *

6 */

7 public class SetQueueTest {

8 // 随即数构造器

9 PRivate static Random r = new Random(10);

10 // 控制测试线程停止的原子变量

11 private static AtomicBoolean stop = new AtomicBoolean(false);

12

13 /***

14 * 基类，供测试用

15 *

16 * @author jiqunpeng@gmail.com

17 *

18 */

19 static abstract class Service {

20 // 操作的计数器

21 protected long count
= 0;

22

23 // 添加一堆元素，并去一个元素

24 public abstract String addAndPick(List<String> elements);

25

26 // 取一个元素

27 public abstract String pickOne();

28

29 /**

30 * 打印操作次数

31 */

32 public void tell() {

33 System.out.println(this + " :\t" + count);

34 }

35 }

36

37 /***

38 * 采用TreeSet的集合工具

39 *

40 * @author jiqunpeng@gmail.com

41 *

42 */

43 static class SetService extends Service {

44 private TreeSet<String> set = new TreeSet<String>();

45

46 @Override

47 public synchronized String addAndPick(List<String> elements) {

48 count++;

49 set.addAll(elements);

50 return set.pollFirst();

51 }

52

53 @Override

54 public synchronized String pickOne() {

55 count++;

56 return set.pollFirst();

57 }

58

59 }

60

61 /***

62 * 采用LinkedList的队列工具

63 *

64 * @author jiqunpeng@gmail.com

65 *

66 */

67 static class QueueService extends Service {

68 private Queue<String> queue = new LinkedList<String>();

69

70 @Override

71 public synchronized String addAndPick(List<String> elements) {

72 count++;

73 queue.addAll(elements);

74 return queue.poll();

75 }

76

77 @Override

78 public synchronized String pickOne() {

79 count++;

80 return queue.poll();

81 }

82 }

83

84 /***

85 * 测试类

86 *

87 * @author jiqunpeng@gmail.com

88 *

89 */

90 static class Tester implements Runnable {

91 // 绑定要测试的工具对象

92 private Service service;

93

94 Tester(Service s) {

95 this.service = s;

96 }

97

98 @Override

99 public void run() {

100 while (stop.get() == false) {

101 List<String> elements = new ArrayList<String>();

102 int len = r.nextInt(200) + 8;

103 for (int i = 0; i < len; i++) {

104 elements.add(String.valueOf(r.nextInt()));

105 }

106 service.addAndPick(elements);

107 for (int i = 0; i < 104; i++)

108 service.pickOne();

109 }

110 }

111 }

112

113 /***

114 * 多线程方式，测试一个插入、删除工具

115 *

116 * @param service

117 * @param time

118 * @param unit

119 * @throws InterruptedException

120 */

121 private static void test(Service service, int time, TimeUnit unit)

122 throws InterruptedException {

123 ExecutorService execs = Executors.newCachedThreadPool();

124 for (int i = 0; i < 20; i++) {

125 execs.execute(new Tester(service));

126 }

127 execs.shutdown();

128 unit.sleep(time);

129 stop.compareAndSet(false, true);

130 service.tell();

131 }

132

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

134 Service setService = new SetService();

135 test(setService, 5, TimeUnit.SECONDS);

136 stop.compareAndSet(true, false);// 重置终止条件

137 Service queueService = new QueueService();

138 test(queueService, 5, TimeUnit.SECONDS);

139 }

140 }
复制代码
　　输出的结果如下：
SetQueueTest$SetService@5e9de959 : 7149859

SetQueueTest$QueueService@11b343e0 : 24303408

　　测试结果让我感到吃惊，TreeSet的插入删除效率确实比LinkedList低，20个线程跑了10秒，使用队列，插入删除24303408次，使用集合，插入删除7149859次。它们之间差距并不大，队列只比集合快2~3倍。属于同一个数量级。于是我这个小型的爬虫应该放心的选择用Set作为unVistedUrls的实现。

转载请注明出处：www.cnblogs.com/fengfenggirl