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會有大量的插入和刪除操作，我認為對集合進行大量的插入刪除性能會比較低，為了測試集合的插入刪除性能對比隊列低多少，我寫了一個簡單的並發測試：

/**
 * 測試集合與隊列的插入與讀寫性能
 * 
 * @author [e-mail]
 * 
 */
public class SetQueueTest {
    // 隨即數構造器
    private static Random r = new Random(10);
    // 控制測試線程停止的原子變量
    private static AtomicBoolean stop = new AtomicBoolean(false);

    /***
     * 基類，供測試用
     * 
     * @author [e-mail]
     * 
     */
    static abstract class Service {
        // 操作的計數器
        protected long count = 0;

        // 添加一堆元素，並去一個元素
        public abstract String addAndPick(List<String> elements);

        // 取一個元素
        public abstract String pickOne();

        /**
         * 打印操作次數
         */
        public void tell() {
            System.out.println(this + " :\t" + count);
        }
    }

    /***
     * 采用TreeSet的集合工具
     * 
     * @author [e-mail]
     * 
     */
    static class SetService extends Service {
        private TreeSet<String> set = new TreeSet<String>();

        @Override
        public synchronized String addAndPick(List<String> elements) {
            count++;
            set.addAll(elements);
            return set.pollFirst();
        }

        @Override
        public synchronized String pickOne() {
            count++;
            return set.pollFirst();
        }

    }

    /***
     * 采用LinkedList的隊列工具
     * 
     * @author [e-mail]
     * 
     */
    static class QueueService extends Service {
        private Queue<String> queue = new LinkedList<String>();

        @Override
        public synchronized String addAndPick(List<String> elements) {
            count++;
            queue.addAll(elements);
            return queue.poll();
        }

        @Override
        public synchronized String pickOne() {
            count++;
            return queue.poll();
        }
    }

    /***
     * 測試類
     * 
     * @author [e-mail]
     * 
     */
    static class Tester implements Runnable {
        // 綁定要測試的工具對象
        private Service service;

        Tester(Service s) {
            this.service = s;
        }

        @Override
        public void run() {
            while (stop.get() == false) {
                List<String> elements = new ArrayList<String>();
                int len = r.nextInt(200) + 8;
                for (int i = 0; i < len; i++) {
                    elements.add(String.valueOf(r.nextInt()));
                }
                service.addAndPick(elements);
                for (int i = 0; i < 104; i++)
                    service.pickOne();
            }
        }
    }

    /***
     * 多線程方式，測試一個插入、刪除工具
     * 
     * @param service
     * @param time
     * @param unit
     * @throws InterruptedException
     */
    private static void test(Service service, int time, TimeUnit unit)
            throws InterruptedException {
        ExecutorService execs = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            execs.execute(new Tester(service));
        }
        execs.shutdown();
        unit.sleep(time);
        stop.compareAndSet(false, true);
        service.tell();
    }

    public static void main(String[] args) throws InterruptedException {
        Service setService = new SetService();
        test(setService, 5, TimeUnit.SECONDS);
        stop.compareAndSet(true, false);// 重置終止條件
        Service queueService = new QueueService();
        test(queueService, 5, TimeUnit.SECONDS);
    }
}

　　輸出的結果如下：

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

 

　　測試結果讓我感到吃驚，TreeSet的插入刪除效率確實比LinkedList低，20個線程跑了10秒，使用隊列，插入刪除24303408次，使用集合，插入刪除7149859次。它們之間差距並不大，隊列只比集合快2~3倍。屬於同一個數量級。於是我這個小型的爬蟲應該放心的選擇用Set作為unVistedUrls的實現。

    轉載請注明出處：www.cnblogs.com/fengfenggirl