synchronized 关键字和 volatile 关键字的区别，AtomicInteger的引入

如果一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要要解决这个问题，就需要把变量声明为 volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进读取。

volatile 关键字的主要作用就是保证变量的可见，且防止指令重排序。

1. volatile修饰的变量具有可见性

可见性-volatile通过加入内存屏障和禁止重排序优化来实现

• 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存

• 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量

public class RunThread extends Thread {

 private boolean isRunning = true;//volatile加上

 public boolean isRunning() {
 return isRunning;
 }

 public void setRunning(boolean isRunning) {
 this.isRunning = isRunning;
 }

 @Override
 public void run() {
 System.out.println("进入到run方法中了");
 while (isRunning == true) {
 }
 System.out.println("线程执行完成了");
 }
}

public class Run {
 public static void main(String[] args) {
 try {
 RunThread thread = new RunThread();
 thread.start();
 Thread.sleep(1000);
 thread.setRunning(false);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
}

main线程 将启动的线程RunThread中的共享变量设置为false， thread.setRunning(false);从而想让RunThread.java 第14行中的while循环结束。但是出现了死循环！

原因分析：

现在有两个线程，一个是main线程，另一个是RunThread。它们都试图修改 第三行的 isRunning变量。按照JVM内存模型，main线程将isRunning读取到本地线程内存空间，修改后，再刷新回主内存。

而在JVM 设置成 -server模式运行程序时，线程会一直在私有堆栈中读取isRunning变量。因此，RunThread线程无法读到main线程改变的isRunning变量

解决方法，在第三行代码处用 volatile 关键字修饰即可。这里，它强制线程从主内存中取 volatile修饰的变量。

2. volatile禁止指令重排

所谓原子性，就是某系列的操作步骤要么全部执行，要么都不执行。

比如，变量的自增操作 i++，分三个步骤：①从内存中读取出变量 i 的值②将 i 的值加1③将 加1 后的值写回内存

这说明 i++ 并不是一个原子操作。因为，它分成了三步，有可能当某个线程执行到了第②时被中断了，那么就意味着只执行了其中的两个步骤，没有全部执行。

关于volatile的非原子性，看个示例：

public class MyThread extends Thread {
 public volatile static int count;
//public  static AtomicInteger count = new AtomicInteger();
 private static void addCount() {
 for (int i = 0; i < 100; i++) {
 count++;
 
//  count.getAndIncrement();
 }
 System.out.println("count=" + count);
 }

 @Override
 public void run() {
 addCount();
 }
}

public class Run {
 public static void main(String[] args) {
 MyThread[] mythreadArray = new MyThread[100];
 for (int i = 0; i < 100; i++) {
 mythreadArray[i] = new MyThread();
 }

 for (int i = 0; i < 100; i++) {
 mythreadArray[i].start();
 }
 }
}

count变量使用volatile修饰, for循环中创建了100个线程,100个线程启动去执行 addCount()，每个线程执行100次加1,期望的正确的结果应该是 100*100=10000，但是，实际上count并没有达到10000;

原因是：volatile修饰的变量并不保证对它的操作（自增）具有原子性。（对于自增操作，可以使用JAVA的原子)AtomicInteger类保证原子自增）

综上，仅靠volatile不能保证线程的安全性。（原子性）

小例子

public class AtomicTest {

    public static void main(String[] args) {
        AtomicDemo atomicDemo = new AtomicDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(atomicDemo).start();
        }
    }
}

class AtomicDemo implements Runnable{
//    private int serialNum = 0;
	private AtomicInteger serialNum = new AtomicInteger(0);

    public int getSerialNum() {
		return serialNum.incrementAndGet();
//        return serialNum++;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":" + getSerialNum());
    }
}

未使用 AtomicIntegerj结果如下：
使用了·AtomicInteger`的运行结果如下：

synchronized

synchronized可作用于一段代码或方法，既可以保证可见性，又能够保证原子性。

JMM关于synchronized的两条规定：

• 线程解锁前，必须把共享变量的最新值刷新到主内存
• 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（注意，加锁与解锁是同一把锁）

作用在代码块，普通方法

锁住的是调用的对象，不同的对象之间是相互不影响的

package com.mmall.concurrency.sysc;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class SynchExaml {
      public void test1(int j) {
          synchronized (this){
              for (int i = 0; i < 10; i++) {
                  log.info("test1 {}-{}" ,j,i);

              }
          }
      }
      public synchronized void test2(){
          for (int i = 0; i <10 ; i++) {
              log.info("test2-{}",i);
          }
      }

    public static void main(String[] args) {
        SynchExaml synchExaml = new SynchExaml();
        SynchExaml synchExaml2 = new SynchExaml();

        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(()->{synchExaml.test1(1);});
        executorService.execute(()->{synchExaml2.test1(2);});

    }
}

作用静态方法作用的所有对象

synchronized 关键字和 volatile 关键字的区别

• volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
• volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
• volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
• volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
• volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化#