ConcurrentSkipListMap性能测试

package vertices;

import java.util.Map;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentSkipListMap;
import org.apache.hadoop.io.FloatWritable;
import org.apache.hadoop.io.IntWritable;
import com.google.common.collect.Maps;

/**
 * 注意 :ConcurrentSkipListMap和ConcurrentLinkedDeque都可以双向访问, ConcurrentSkipListMap可以将keyset进行降序遍历,ConcurrentLinkedDeque提供降序迭代器
 * @author Administrator
 *
 */
public class VerticesTest {

	public static void main(String[] args) {
		int VERTICES_NUMBER_0 =  400000;
		int VERTICES_NUMBER_1 = 1000000;

        //case1
		long start = System.currentTimeMillis();
		 ConcurrentMap<IntWritable, TestVertex> vertexMap0 = Maps
		 .newConcurrentMap();
		 ConcurrentMap<IntWritable, TestVertex> vertexMap1 = Maps
		 .newConcurrentMap();
		 for (int i = 0; i < VERTICES_NUMBER_0; i++) {
		 vertexMap0.put(new IntWritable(i), new TestVertex(
		 new IntWritable(i), new FloatWritable(i)));
		 }
		 for (int i = 0; i < VERTICES_NUMBER_1; i++) {
		 vertexMap1.put(new IntWritable(i), new TestVertex(
		 new IntWritable(i), new FloatWritable(i)));
		 }
		 System.out.println("ConcurrentMap load last "
		 + (System.currentTimeMillis() - start) + " ms");
		
		 start = System.currentTimeMillis();
		 Thread t0 = new Thread(new MapWorker(vertexMap0));
		 Thread t1 = new Thread(new MapWorker(vertexMap1)) ;
		 try {
		 t0.start() ;
		 t1.start();
		 t0.join() ;
		 t1.join();
		 } catch (InterruptedException e) {
		 e.printStackTrace();
		 }
		 System.out.println("ConcurrentMap run last "
		 + (System.currentTimeMillis() - start) + " ms");

         //case2
		 start = System.currentTimeMillis();
		 ConcurrentSkipListMap<IntWritable, TestVertex> skipMap0 = new ConcurrentSkipListMap<IntWritable, TestVertex> () ;
		 ConcurrentSkipListMap<IntWritable, TestVertex> skipMap1 = new ConcurrentSkipListMap<IntWritable, TestVertex> () ;
		 for (int i = 0; i < VERTICES_NUMBER_0; i++) {
			 skipMap0.put(new IntWritable(i), new TestVertex(
		 new IntWritable(i), new FloatWritable(i)));
		 }
		 for (int i = 0; i < VERTICES_NUMBER_1; i++) {
			 skipMap1.put(new IntWritable(i), new TestVertex(
		 new IntWritable(i), new FloatWritable(i)));
		 }
		 System.out.println("ConcurrentSkipListMap load last "
		 + (System.currentTimeMillis() - start) + " ms");
		
		 start = System.currentTimeMillis();
		 t0 = new Thread(new MapWorker(skipMap0));
		 t1 = new Thread(new MapWorker(skipMap1)) ;
		 try {
		 t0.start() ;
		 t1.start();
		 t0.join() ;
		 t1.join();
		 } catch (InterruptedException e) {
		 e.printStackTrace();
		 }
		 System.out.println("ConcurrentSkipListMap run last "
		 + (System.currentTimeMillis() - start) + " ms");
		
	    //case3
		ConcurrentLinkedDeque<TestVertex> vertices0 = new ConcurrentLinkedDeque<TestVertex>();
		ConcurrentLinkedDeque<TestVertex> vertices1 = new ConcurrentLinkedDeque<TestVertex>();
		start = System.currentTimeMillis();
		for (int i = 0; i < VERTICES_NUMBER_0; i++) {
			vertices0.add(new TestVertex(new IntWritable(i), new FloatWritable(
					i)));
		}
		for (int i = 0; i < VERTICES_NUMBER_1; i++) {
			vertices1.add(new TestVertex(new IntWritable(i), new FloatWritable(
					i)));
		}
		System.out.println("ConcurrentLinkedDeque Load last "
				+ (System.currentTimeMillis() - start) + " ms");

		start = System.currentTimeMillis();
		t0 = new Thread(new DequeWorker(vertices0));
		t1 = new Thread(new DequeWorker(vertices1));
		try {
			t0.start();
			t1.start();
			t0.join();
			t1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("ConcurrentLinkedDeque run last "
				+ (System.currentTimeMillis() - start) + " ms");
		System.out.println(vertices1.getLast().value);
	}
}

class TestVertex {
	IntWritable id;
	FloatWritable value;
	int flag = 0;

	public TestVertex(IntWritable id, FloatWritable value) {
		this.id = id;
		this.value = value;
	}
}

class MapWorker implements Runnable {
	ConcurrentMap<IntWritable, TestVertex> vertexMap;

	public MapWorker(ConcurrentMap<IntWritable, TestVertex> vertexMap) {
		this.vertexMap = vertexMap;
	}

	@Override
	public void run() {
		for (Map.Entry<IntWritable, TestVertex> e : vertexMap.entrySet()) {
			TestVertex v = e.getValue();
			v.value.set(v.value.get() * 2);
		}
	}
}

class DequeWorker implements Runnable {
	ConcurrentLinkedDeque<TestVertex> vertices;

	public DequeWorker(ConcurrentLinkedDeque<TestVertex> vertices) {
		this.vertices = vertices;
	}

	@Override
	public void run() {
//		long start = System.currentTimeMillis();
		for (TestVertex v : vertices) {
			v.value.set(v.value.get() * 2);
			v.flag = 1 ;
		}
//		System.out.println(Thread.currentThread().getName() + " last " + (System.currentTimeMillis() - start) + " ms" );
	}
}

测试结果:

ConcurrentMap load last 1633 ms
ConcurrentMap run last 103 ms
ConcurrentSkipListMap load last 1178 ms
ConcurrentSkipListMap run last 38 ms
ConcurrentLinkedDeque Load last 122 ms
ConcurrentLinkedDeque run last 21 ms