【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. package com.xwtech.uomp.base.action.handler.admin;
   
2. 
   
3. public class asdsd {
   
4.          /**
   
5.          测试集合与队列的插入与读写性能   **/
   
6.           public class SetQueueTest {      // 随即数构造器
   
7.            
   
8.                   private static Random r = new Random(10);    // 控制测试线程停止的原子变量
   
9.            
   
10.                   private static AtomicBoolean stop = new AtomicBoolean(false);  12 
    
11.     
    
12.                   static abstract class Service {    
    
13.                           
    
14.                           // 操作的计数器
    
15.                protected long count = 0; 
    
16.                  // 添加一堆元素，并去一个元素
    
17.                  public abstract String addAndPick(List<String> elements);  
    
18.                  // 取一个元素
    
19.                 public abstract String pickOne();  
    
20.               
    
21.                 public void tell() {       
    
22.                         System.out.println(this + " :t" + count);        
    
23.                         }    
    
24.                 }  
    
25.           }
    
26.             static class SetService extends Service { 
    
27.                     private TreeSet<String> set = new TreeSet<String>();   
    
28.                  @Override        
    
29.                  public synchronized String addAndPick(List<String> elements) 
    
30.                  {           
    
31.                          count++;    
    
32.                          set.addAll(elements);      
    
33.                          return set.pollFirst();    
    
34.                          }   
    
35.                 @Override          
    
36.                 public synchronized String pickOne()
    
37.                 {          
    
38.                         count++;     
    
39.                         return set.pollFirst();  
    
40.                         }  
    
41.             }  
    
42.     static class QueueService extends Service {    
    
43.             private Queue<String> queue = new LinkedList<String>(); 
    
44.             
    
45.                 @Override          
    
46.                 public synchronized String addAndPick(List<String> elements)
    
47.                 {             count++;      
    
48.                 queue.addAll(elements);      
    
49.                 return queue.poll();       
    
50.                 }   
    
51.                  @Override     
    
52.                  public synchronized String pickOne() {  
    
53.                          count++;         
    
54.                          return queue.poll();         
    
55.                          }   
    
56.                  }  
    
57.      static class Tester implements Runnable {    
    
58.              // 绑定要测试的工具对象
    
59.                  private Service service;  
    
60.                  
    
61.              Tester(Service s) {           
    
62.                      this.service = s;     
    
63.                      }  
    
64.                   @Override         
    
65.                   public void run() {   
    
66.                           while (stop.get() == false) {     
    
67.                 List<String> elements = new ArrayList<String>();  
    
68.                 int len = r.nextInt(200) + 8;            
    
69.                 for (int i = 0; i < len; i++) {       
    
70.                         elements.add(String.valueOf(r.nextInt()));  
    
71.                         }                
    
72.                 service.addAndPick(elements);        
    
73.                 for (int i = 0; i < 104; i++)     
    
74.                         service.pickOne();      
    
75.                 }       
    
76.                           }    
    
77.                   }  
    
78.              private static void test(Service service, int time, TimeUnit unit)
    
79.                              throws InterruptedException 
    
80.                              {       
    
81.                      ExecutorService execs = Executors.newCachedThreadPool(); 
    
82.                      for (int i = 0; i < 20; i++) {    
    
83.                              execs.execute(new Tester(service)); 
    
84.                              }        
    
85.                      execs.shutdown();    
    
86.                      unit.sleep(time);      
    
87.                      stop.compareAndSet(false, true);    
    
88.                      service.tell();    
    
89.                      }  
    
90.             public static void main(String[] args) throws InterruptedException 
    
91.             {       
    
92.                     Service setService = new SetService();    
    
93.                     test(setService, 5, TimeUnit.SECONDS);  
    
94.                     stop.compareAndSet(true, false);// 重置终止条件
    
95.                Service queueService = new QueueService(); 
    
96.                test(queueService, 5, TimeUnit.SECONDS);    
    
97.                } 
    
98.             }
    

复制代码

输出的结果如下：

1. SetQueueTest$SetService@5e9de959 :      7149859 SetQueueTest$QueueService@11b343e0 :    24303408

复制代码

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

复制代码