1.cas
它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。
2. synchronized的三种应用方式
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁
3. ReenTrantLock 实现接口Lock
ReentrantLock是一个互斥锁，也是一个可重入锁（Reentrant就是再次进入的意思）。ReentrantLock锁在同一个时间点只能被一个线程锁持有，但是它可以被单个线程多次获取，每获取一次AQS的state就加1，每释放一次state就减1。还记得synchronized嘛，它也是可重入的，一个同步方法调用另外一个同步方法是没有问题的。
废话不多说，上代码：
1 public static void main(String[] args)throws Exception { 2 CountDownLatch countDownLatch = new CountDownLatch(1);//比较公平测量 3 //全局变量时候使用：volatile这个关键子的作用是修饰类的全局变量的 4 int k =0, m = 0,n=0,p=0; 5 Lock lock = new ReentrantLock(false); 6 Lock lockFair = new ReentrantLock(true); 7 Long time =System.currentTimeMillis(); 8 //无锁 9 Run run = new Run(k,time,countDownLatch); 10 //sync锁 11 RunSyn runSyn = new RunSyn(p,time,countDownLatch); 12 //reentrantLock 非公平锁 13 RunLock runLock = new RunLock(m,lock,time,"unfair",countDownLatch); 14 //reentrantLock 公平锁 15 RunLock runLockFair = new RunLock(m,lockFair,time,"fair",countDownLatch); 16 //cas 锁 17 RunCas runCas = new RunCas(n,new AtomicInteger(),time,countDownLatch); 18 for (int i = 0; i < 3; i++) { 19 new Thread(runLockFair).start(); 20 new Thread(run).start(); 21 new Thread(runLock).start(); 22 new Thread(runCas).start(); 23 new Thread(runSyn).start(); 24 } 25 System.out.println("---------》比赛开始《--------"); 26 countDownLatch.countDown();//启动所有阻塞的线程 27 } 28 29 /** 30 * 无 锁 31 */ 32 static class Run implements Runnable{ 33 int k; 34 Long time; 35 CountDownLatch countDownLatch; 36 public Run(int j,Long time,CountDownLatch countDownLatch){ 37 this.k = j; 38 this.time = time; 39 this.countDownLatch = countDownLatch; 40 } 41 @Override 42 public void run() { 43 try { 44 countDownLatch.await(); 45 } catch (InterruptedException e) { 46 e.printStackTrace(); 47 } 48 for (int i = 0; i < 1000000; i++) { 49 k++; 50 //System.out.println("i--->"+i); 51 } 52 System.out.println("无锁 k--->"+k+"---->"+(System.currentTimeMillis()-time)); 53 } 54 } 55 56 /** 57 * lock 锁 58 */ 59 static class RunLock implements Runnable{ 60 int m; 61 String sync; 62 Long time; 63 Lock lock; 64 CountDownLatch countDownLatch; 65 public RunLock(int j,Lock lock,Long time,String sync,CountDownLatch countDownLatch){ 66 this.m = j; 67 this.time = time; 68 this.lock = lock; 69 this.sync = sync; 70 this.countDownLatch = countDownLatch; 71 } 72 @Override 73 public void run() { 74 try { 75 countDownLatch.await(); 76 } catch (InterruptedException e) { 77 e.printStackTrace(); 78 } 79 for (int i = 0; i < 1000000; i++) { 80 lock.lock(); 81 m++; 82 lock.unlock(); 83 } 84 System.out.println(sync+"lock m--->"+m+"---->"+(System.currentTimeMillis()-time)); 85 } 86 } 87 88 /** 89 * CAS 90 */ 91 static class RunCas implements Runnable{ 92 AtomicInteger atomicInteger; 93 int n; 94 Long time; 95 CountDownLatch countDownLatch; 96 public RunCas(int j,AtomicInteger atomicInteger,Long time,CountDownLatch countDownLatch){ 97 this.n = j; 98 this.time = time; 99 this.atomicInteger = atomicInteger; 100 this.countDownLatch = countDownLatch; 101 } 102 @Override 103 public void run() { 104 try { 105 countDownLatch.await(); 106 } catch (InterruptedException e) { 107 e.printStackTrace(); 108 } 109 for (int i = 0; i < 1000000; i++) { 110 getLock(atomicInteger); 111 n++; 112 unLock(atomicInteger); 113 } 114 System.out.println("cas n--->"+n+"---->"+(System.currentTimeMillis()-time)); 115 } 116 } 117 118 /** 119 * 获取锁 120 * @param atomicInteger 121 * @return 122 */ 123 private static boolean getLock(AtomicInteger atomicInteger) { 124 while (true){ 125 boolean flag = atomicInteger.compareAndSet(0,1); 126 if (flag){ 127 return true; 128 } 129 } 130 } 131 132 /** 133 * 释放锁 134 * @param atomicInteger 135 * @return 136 */ 137 private static boolean unLock(AtomicInteger atomicInteger) { 138 while (true){ 139 boolean flag = atomicInteger.compareAndSet(1,0); 140 if (flag){ 141 return true; 142 } 143 } 144 } 145 146 /** 147 * synchronized 148 */ 149 static class RunSyn implements Runnable{ 150 int p; 151 Long time; 152 CountDownLatch countDownLatch; 153 public RunSyn(int j,Long time,CountDownLatch countDownLatch){ 154 this.p = j; 155 this.time = time; 156 this.countDownLatch = countDownLatch; 157 } 158 @Override 159 public void run() { 160 try { 161 countDownLatch.await();//阻塞线程 162 } catch (InterruptedException e) { 163 e.printStackTrace(); 164 } 165 synchronized(this){ 166 for (int i = 0; i < 1000000; i++) { 167 p++; 168 } 169 } 170 System.out.println("synchronized p--->"+p+"---->"+(System.currentTimeMillis()-time)); 171 } 172 }
结果：
---------》比赛开始《-------- synchronized p--->1007776---->15 synchronized p--->2000000---->15 无锁 k--->246073---->31 无锁 k--->1108336---->46 无锁 k--->1247421---->46 synchronized p--->3000000---->46 unfairlock m--->2824215---->109 unfairlock m--->2959808---->109 unfairlock m--->3000000---->109 cas n--->2961861---->375 cas n--->2961864---->375 cas n--->3000000---->375 fairlock m--->2995778---->32035 fairlock m--->3000000---->32082 fairlock m--->3000000---->32082
三个线程每个线程累加一百万，从结果看出来无锁出现并发问题，synchronized 性能最好 非公平锁unfairlock与cas性能差不多 公平锁fairlock性能较差