synchronized和ReentrantLock的性能比较

public class SycLockTest {
  static String case1File = "c1.txt";
  static String case2File = "c2.txt";
  static volatile FileWriter caseWriter;
  static BlockingQueue<Long> dataQ;
  static String fileName="a.txt";
  static CountDownLatch countdown;
  static Object lock =new Object();
  static Lock reentrantLock = new ReentrantLock();
  static int x=10;
  volatile static List<Long> record;
  static int before = 500;
  static int redo = 50;
  static int vl=0;
  static BlockingQueue bq=new ArrayBlockingQueue(1000);
  static Object[] abc= new Object[100];
  static void fgh(){
    cal(before);
    long start = System.nanoTime();
    synchronized (lock){
      cal(redo);
      //writeFile();
      //add();
    }
    long cost =System.nanoTime()-start;
    addRecord(cost);
    dataQ.add(cost);
    //System.out.println(Thread.currentThread().getName());
    countdown.countDown();
  }

  static void efg(){
    cal(before);
    long start = System.nanoTime();
    reentrantLock.lock();
    cal(redo);
    //writeFile();
    //add();
    reentrantLock.unlock();
    long cost =System.nanoTime()-start;
    addRecord(cost);
    dataQ.add(cost);
    //System.out.println(Thread.currentThread().getName());
    countdown.countDown();
  }

  static void add(){
//    vl++;
//    vl--;
//    bq.add(lock);
//    bq.remove(lock);
//    bq.add(lock);
//    bq.remove(lock);
    for(int a=0;a<abc.length;a++){
      abc[a]=lock;
    }
  }
  static void cal(int repeat){
    while (repeat-->0){
      x= 1<<32;
    }
  }

  static void writeFile() {
    try(FileWriter fw = new FileWriter(fileName)){
      fw.write("xxxxxxxxxxxxxxxxxx");
      fw.write(System.lineSeparator());
      fw.write("yyyyyyyyyyyyyy");
    } catch (IOException e) {

    }
  }
  synchronized static void addRecord(long value){
    record.add(value);
  }
  static void startCase(int tCount,int reCall, Runnable runnable, List<Thread> threads,String aaa) throws InterruptedException {
    long sum=0;
    while(reCall-->0){
      threads.clear();
      record.clear();
      countdown = new CountDownLatch(tCount);
      for(int i=0;i<tCount;i++){
        Thread t = new Thread(runnable);
        t.setName(aaa+"-"+i);
        threads.add(t);
      }

      threads.parallelStream().forEach(t->t.start());
      countdown.await();
      long cost =  record.stream().reduce(0L,(x,y)->Long.sum(x,y));
      sum = Long.sum(sum,Math.round(cost));
    }
    System.out.println(sum);
  }

  static void writeResult()  {
    try {
      while (true) {
        long value = dataQ.take();
        caseWriter.write(value + System.lineSeparator());
      }
    }catch (Exception e){}
  }
  public static void main(String[] args) throws InterruptedException, IOException {
    int thCount = 20;//thread count
    int inputReCall = 500;//repeat count
    if(args.length>0){
      thCount = Integer.valueOf(Optional.ofNullable(args[0]).orElse("30"));
    }
    if(args.length>1){
      inputReCall = Integer.valueOf(Optional.ofNullable(args[1]).orElse("10"));
    }
    Files.deleteIfExists(Paths.get(fileName));
    Files.createFile(Paths.get(fileName));
    record = new CopyOnWriteArrayList();
    List<Thread> threads = new ArrayList<>(thCount);
    dataQ = new ArrayBlockingQueue<>(thCount*inputReCall);
    Thread dataWriter = new Thread(SycLockTest::writeResult);
    dataWriter.start();
    Files.deleteIfExists(Paths.get(case1File));
    Files.createFile(Paths.get(case1File));
    try{
      caseWriter = new FileWriter(case1File,true);
      startCase(thCount, inputReCall, SycLockTest::fgh, threads, "pppppppp");
    }catch(Exception e){ }finally {
      if(caseWriter!=null) caseWriter.close();
    }
    Files.deleteIfExists(Paths.get(case2File));
    Files.createFile(Paths.get(case2File));
    try {
      caseWriter = new FileWriter(case2File,true);
      startCase(thCount, inputReCall, SycLockTest::efg, threads, "qqqqqqqqqq");
    }catch(Exception e){ }finally {
        if(caseWriter!=null) caseWriter.close();
      }
  }

}