锁策略（CAS synchronized)

目录

1.CAS优化过程

2.synchronized优化过程

---

一.CAS优化过程

1.CAS实现原子类

import java.util.concurrent.atomic.AtomicInteger;
//使用CAS实现原子类
public class demo25 {
    //public static int count = 0;
    public static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for(int i=0;i<5000;i++){
               //count++;
               count.getAndIncrement();
           }
        });
        Thread t2 = new Thread(()->{
           for(int i=0;i<5000;i++){
               count.getAndIncrement();
           }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

定义AtomicInteger类型对象，就使得在不加锁的情况下用CAS的原子操作保证count输出10000。

  AtomicInteger执行过程：

class AtomicInteger {
    private int value;
    public int getAndIncrement() {
       int oldValue = value;
       while((CAS(value,oldValue,oldValue+1) ！= true) {
           oldValue = value;
       }
       return oldValue;
     }
}

2.实现自旋锁

public class SpinLock{
    private Thread owner = null;
    public void lock(){
        while(!CAS(this.owner,null,Thread.currentThread())){
        }
    }
    public void unlock(){
        this.owner = null;
    }
}

 owner为null时，说明CAS成功，循环结束；owner不为null时，说明当前锁正在被其他线程占用，继续循环。

ABA问题：例如在银行存取款的情况，比较余额，余额相同时进行修改，但是余额可以变大可以变小，所以就引入了版本号，约定版本好只增不减来避免ABA问题。

二.synchronized优化过程

1.锁升级：synchronized特性：（1）开始时乐观锁，如果所冲突频繁，就转换为悲观锁了。（2）即是轻量级锁，也是重量级锁。（3）轻量级锁由自旋锁实现，重量级锁由挂起等待锁实现。（4）不是读写锁。（5）是非公平锁。（6）是可重入锁。

synchronized加锁过程：（1）未加锁。

（2）偏向锁（刚开始加锁，未产生竞争）。

（3）轻量级锁（产生了锁竞争）。

（4）锁竞争正激烈。

2.锁消除：编译器自动判定，若认为这个代码没必要加锁，就自动去掉锁。

3.锁粗化：如果一段代码中频繁的进行加锁解锁，就简化为对整段代码加锁。

锁的粒度：synchronized包含的代码范围是大还是小，范围越大，粒度越粗，范围越小，粒度越细。