synchronized并不比lock慢

来做个测试，先建立一个lock测试类，同时启动多条线程启动完毕后同时争抢修改共享变量
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;

public class LockTest extends Thread{
    
    private Lock lock;
    private CyclicBarrier cyclicBarrier;
    public static AtomicInteger startfat = new  AtomicInteger(0);
    public static Integer sum =0 ;
    public static long startTime;
    
    public LockTest(Lock lock, CyclicBarrier cyclicBarrier) {
        super();
        this.lock = lock;
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
   public void run() {
       
        try {
            cyclicBarrier.await();//栅栏保证所有线程准备就绪，一起争夺，模拟多线程竞争环境
            if (startfat.compareAndSet(0, 1)) {
                startTime=System.currentTimeMillis();//记录吹响号角的第一时间
            }
            
            lock.lock();
            sum++;
            lock.unlock();
            System.out.println("time:"+(System.currentTimeMillis()-startTime)+" sum:"+sum);    
        } catch (Exception e) {
            e.printStackTrace();
        }
  
   }

 

再建立一个synchronized测试类

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;

public class CyncTest extends Thread{
    
    private CyclicBarrier cyclicBarrier;
    public static AtomicInteger startfat = new  AtomicInteger(0);
    public static Integer sum =0 ;
    public static long startTime;
    
    public CyncTest(CyclicBarrier cyclicBarrier) {
        super();
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
   public void run() {
       
        try {
            cyclicBarrier.await();//栅栏保证所有线程准备就绪，一起争夺，模拟多线程竞争环境
            if (startfat.compareAndSet(0, 1)) {
                startTime=System.currentTimeMillis();//记录吹响号角的第一时间
            }
            
            synchronized(sum) {
                sum++;    
            }
    
            System.out.println("time:"+(System.currentTimeMillis()-startTime)+" sum:"+sum);    
        } catch (Exception e) {
            e.printStackTrace();
        }
  
   }

再来写个main 方法启动多线程

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LckAndSyncTest {
    
    public static int type=1;

    private static int toatl =1000;
    
    public static Lock lock =new ReentrantLock();
    
    public static  CyclicBarrier cyclicBarrier = new CyclicBarrier(toatl);
    
    public static void main(String[] args) {

        if (type == 0) {
            for (int i = 0; i < toatl; i++) {
                new LockTest(lock, cyclicBarrier).start();
            }
        } else if(type == 1){
            for (int i = 0; i < toatl; i++) {
                new CyncTest(cyclicBarrier).start();
            }

        }
    }

    

 

设置 type = 0  ,运行 输出  

。。。。

time:233 sum:999
time:232 sum:983
time:233 sum:1000
time:232 sum:981
time:232 sum:980
time:233 sum:998
time:233 sum:997
time:233 sum:995
time:232 sum:990

最大时间是233毫秒

 

接着修改type =1

time:219 sum:986
time:219 sum:983
time:220 sum:987
time:220 sum:988
time:220 sum:989
time:220 sum:990
time:219 sum:985
time:220 sum:991
time:220 sum:992
time:221 sum:994
time:221 sum:993

可以看出   本次实验中  synchronized 比  Lock还要快那么一点点，基本可以忽略不计。在多线程竞争所得情况下都是串行得。

修改total 为100再次实验，顺序不变。结果

lock:

time:19 sum:99
time:19 sum:98
time:19 sum:98
time:16 sum:96
time:15 sum:95
time:15 sum:93
time:15 sum:92
time:15 sum:91
time:15 sum:89
time:15 sum:88
time:15 sum:86

 

synchronized:

time:12 sum:69
time:11 sum:67
time:11 sum:66
time:11 sum:64
time:11 sum:63
time:38 sum:99
time:38 sum:99
time:38 sum:98
time:38 sum:97
time:17 sum:96
time:16 sum:93

可以看出 lock 比它快一点，synchronized 出现不稳定情况，看过我前面博文的人知道，synchronized有三中锁，切换需要成本。这可能是它性能不稳定的原因。

total为10的时候无差异，都是一毫秒。

time:1 sum:10

这个实验可能存在先后编译的问题，我们都知道同样的代码，后面跑的比前面快，我们这次调整type 1和 type 0的执行顺序，看就看结果如何

toatl =1000，先跑 synchronized  

time:200 sum:1000

lock:

time:236 sum:1000

toatl =100;

 synchronized  

time:21 sum:100

lock:

time:23 sum:100

这样synchronized  比lock()性能要好。

总体来说，synchronized 并不比lock锁要差，以后谁还和我逼逼 说synchronized 性能不行，我吊死他，synchronized的性能已经得到了极大的提升。