使用无锁的方式和有锁的方式的程序性能对比

  1 import java.util.concurrent.ExecutorService;
  2 import java.util.concurrent.Executors;
  3 import java.util.concurrent.TimeUnit;
  4 import java.util.concurrent.atomic.AtomicInteger;
  5 
  6 public class TestAtomic {
  7 
  8     // 设置线程数量
  9     private static int N = 1000;
 10     // 设置最大值
 11     private static int M = 1000000;
 12 
 13     /**
 14      * 无锁方法
 15      * 
 16      * @throws InterruptedException
 17      */
 18     private static void atomicMethod() throws InterruptedException {
 19         AtomicRun atomicRun = new AtomicRun();
 20         AtomicRun.endValue = M;
 21 
 22         ExecutorService service = Executors.newFixedThreadPool(N);
 23         // 开始时间
 24         long starttime = System.currentTimeMillis();
 25         for (int i = 0; i < N; i++) {
 26             service.submit(atomicRun);
 27         }
 28         service.shutdown();
 29         service.awaitTermination(Integer.MAX_VALUE, TimeUnit.MILLISECONDS);
 30         // 结束时间
 31         long endTime = System.currentTimeMillis();
 32         System.out.println("无锁线程数量为 ： " + N + " 开始时间为 ： " + starttime
 33                 + " 结束时间为 ： " + endTime + " 耗费时间为 ： " + (endTime - starttime)
 34                 + "ms" + " value:" + AtomicRun.atomicInteger);
 35     }
 36 
 37     /**
 38      * 加锁方法
 39      * 
 40      * @throws InterruptedException
 41      */
 42     private static void synMethod() throws InterruptedException {
 43         SynRun synRun = new SynRun();
 44         SynRun.endValue = M;
 45 
 46         ExecutorService service = Executors.newFixedThreadPool(N);
 47         long starttime = System.currentTimeMillis();
 48         for (int i = 0; i < N; i++) {
 49             service.submit(synRun);
 50         }
 51         service.shutdown();
 52         service.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
 53         long endTime = System.currentTimeMillis();
 54         System.out.println("有锁线程数量为 ： " + N + " 开始时间为 ： " + starttime
 55                 + " 结束时间为 ： " + endTime + " 耗费时间为 ： " + (endTime - starttime)
 56                 + "ms" + " value:" + AtomicRun.atomicInteger);
 57     }
 58 
 59     public static void main(String[] args) throws InterruptedException {
 60         System.out.println("当线程数量为 ： " + N + "时：");
 61         atomicMethod();
 62         synMethod();
 63     }
 64 }
 65 
 66 /**
 67  * 
 68  * @author 秦孔祥
 69  * 
 70  */
 71 class AtomicRun implements Runnable {
 72 
 73     protected static AtomicInteger atomicInteger = new AtomicInteger();
 74     protected static int endValue;
 75 
 76     @Override
 77     public void run() {
 78         int startValue = atomicInteger.get();
 79         while (startValue < endValue) {
 80             startValue = atomicInteger.incrementAndGet();
 81         }
 82     }
 83 }
 84 
 85 class SynRun implements Runnable {
 86 
 87     protected static int startValue;
 88     protected static int endValue;
 89 
 90     @Override
 91     public void run() {
 92         while (startValue < endValue) {
 93             addValue();
 94         }
 95     }
 96 
 97     private synchronized void addValue() {
 98         startValue++;
 99     }
100 }