java concurrent学习-简单的synchronized vs lock vs atomic

package concurrentstudy;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;



public class CompareLock {
	public static  Integer count=0;
	public static AtomicInteger ai = new AtomicInteger(0);


	public static void main(String[] args) {
		
		ExecutorService es = Executors.newFixedThreadPool(100);
		long start= System.currentTimeMillis();
		for(int i=1;i<=200000;i++){
			es.submit(new Runnable() {
				
				public void run() {
					synchronized (ExecutorService.class) {
						count+=1;
					}
					
				}
			});
		}

		es.shutdown();
		while(!es.isTerminated()){
			
		}
		
		long end= System.currentTimeMillis();
		System.out.println(end-start);
		System.out.println(count);
		
		ExecutorService es2 = Executors.newFixedThreadPool(100);
		count=0;
		final Lock lock = new ReentrantLock ();
		long start2= System.currentTimeMillis();
		for(int i=1;i<=200000;i++){
			es2.submit(new Runnable() {
				
				public void run() {
					
					lock.lock();
					count+=1;
					lock.unlock();
					
				}
			});
		}
		es2.shutdown();
		while(!es2.isTerminated()){
			
		}
		
		long end2= System.currentTimeMillis();
		System.out.println(end2-start2);
		System.out.println(count);
		
		ExecutorService es3 = Executors.newFixedThreadPool(100);
		long start3= System.currentTimeMillis();
		for(int i=1;i<=200000;i++){
			es3.submit(new Runnable() {
				
				public void run() {
					CompareLock.ai.incrementAndGet();
				}
			});
		}
		es3.shutdown();
		while(!es3.isTerminated()){
			
		}
		long end3= System.currentTimeMillis();
		System.out.println(end3-start3);
		System.out.println(ai);
	}
}

输出:

437
200000
313
200000
265
200000