volatile、synchronized的使用

synchronized

在JDK1.6后，synchronized与Lock性能上差距很小了（优化了很多，自旋锁，自适应自旋锁、偏向锁，轻量级锁等），synchronized不用手动释放锁，很实用

volatile

volatile保证了可见性。被它修改的属性改完后会强制让工作内存失效。去主存拿。（也可以使用java.util.concurrent.atomic下的类）

接下来测试以下代码

package com.arno.train.lock;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class FunctionAddSynchronizedError {
          
   

    volatile int a = 1;
    volatile int b = 1;

    public synchronized void add() {
          
   
        log.info("add start");
        for (int i = 0; i < 100000; i++) {
          
   
            a++;
            b++;
        }
        log.info("add done");
    }

    public void compare() {
          
   
        log.info("compare start");
        for (int i = 0; i < 100000; i++) {
          
   
            if (a < b) {
          
   
                log.info("a:{},b:{},{}", a, b, a > b);
                //最后的a>b应该始终是false的吗？
            }
        }
        log.info("compare done");
    }

}

public static void main(String[] args) {
          
   
        FunctionAddSynchronizedError interesting = new FunctionAddSynchronizedError();
        new Thread(interesting::add).start();
        new Thread(interesting::compare).start();
    }

运行上述代码得到结果： 分析

a < b 被编译器分为三步：获取a 获取b 再做比较； 所以需要做个处理，在add时，compare无法读取到a和b。

处理后的代码：

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class FunctionAddSynchronizedRight {
          
   

    int a = 1;
    int b = 1;

    public synchronized void add() {
          
   
        log.info("add start");
        for (int i = 0; i < 100000; i++) {
          
   
            a++;
            b++;
        }
        log.info("add done");
    }

    public synchronized void compare() {
          
   
        log.info("compare start");
        for (int i = 0; i < 100000; i++) {
          
   
            if (a < b) {
          
   
                log.info("a:{},b:{},{}", a, b, a > b);
                //最后的a>b应该始终是false的吗？
            }
        }
        log.info("compare done");
    }

}

运行上述代码得到结果：