在多线程并发编程中synchronized和volatile都扮演着重要的角色，synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。而volatile是轻量级的 synchronized，它在多处理器开发中保证了共享变量的“可见性”。
先不管synchronized干嘛用，举个例子：火车票购票。比如火车站有10台售票机，现在有100张票，每张票都是唯一的，票号1-100。现在10台售票机后面都有人在排队买10号票，那么就会出现一种情况，可能在同一时刻有多个人同时点击了购票，如果什么操作都不做，那么就会售出多张重复的10号票，这样就会造成很严重的后果。
那么synchronized干了个什么事情呢？它所做的就是当有一个人对当前10号票进行购买操作时，这个购票订单就被锁定了，别人再想买这个票不行的，只能买下一张11号票。
最开始了解到synchronized其实是操作系统课上，操作系统中有个概念叫管程，它是一种高级同步原语，其中包括了过程、变量即数据结构。synchronized实现了管程的访问机制，你可以访问它的过程，但是不能在管程以外的过程中访问他的数据结构。（也可以认为这些数据结构是私有的）它有一个主要特征：当一个进程调用管程过程时，该过程的前几条指令将检查在管程中是否有其他进程。如果有，调用进程阻塞，如果没有，调用进程进入管程。
在Java中支持管程，也就是使用synchronized关键字。只要将关键字加入到方法声明中，java保证一旦某个线程执行该方法，就不允许其他线程执行该类中的任何synchronized方法。
eg：
Object testObject =new Object();
synchronized (testObject ){
//此处的代码只有占有了testObject 后才可以执行
}
如下图所示，synchronized表示当前线程独占了对象someObject，如果有其他线程试图占有对象testObject ，就会等待，直到当前线程释放对testObject 的占用。testObject 又叫同步对象，所有的对象都可以作为同步对象。为了达到同步的效果，必须使用同一个同步对象。释放同步对象的方式： synchronized 块自然结束，或者有异常抛出。
public class TestThread {
public static String now(){
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
public static void main(String[] args) {
final Object testObject = new Object();
Thread t1 = new Thread(){
public void run(){
try {
System.out.println( now()+" t1 线程已经运行");
System.out.println( now()+this.getName()+ " 试图占有对象：testObject ");
synchronized (testObject ) {
System.out.println( now()+this.getName()+ " 占有对象：testObject ");
Thread.sleep(5000);
System.out.println( now()+this.getName()+ " 释放对象：testObject ");
}
System.out.println(now()+" t1 线程结束");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
t1.setName(" t1");
t1.start();
Thread t2 = new Thread(){
public void run(){
try {
System.out.println( now()+" t2 线程已经运行");
System.out.println( now()+this.getName()+ " 试图占有对象：testObject ");
synchronized (testObject ) {
System.out.println( now()+this.getName()+ " 占有对象：testObject ");
Thread.sleep(5000);
System.out.println( now()+this.getName()+ " 释放对象：testObject ");
}
System.out.println(now()+" t2 线程结束");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
t2.setName(" t2");
t2.start();
}
}
1）同步方法（包括普通方法和静态方法）
public synchornized void func(){
}
public synchornized static void func(){
}
2）同步代码块
private final Object lock = new Object();
public void func(){
synchornized(lock){
...
}
}使用示例：synchornized同步锁实现3个线程循环打印数字，使用线程1，打印1，2，3，4，5. 线程2，打印6，7，8，9，10.线程3，打印11，12，13，14，15.依次循环打印，直到
打印至60
package sefl.thread;
/**
* Description :
* Created by Resumebb
* Date :2021/2/3
*/
public class test6 {
static class MyThread{
int num=1;
int threadNum = 0;
public synchronized void fun(){
int name=Integer.parseInt(Thread.currentThread().getName());
while((threadNum % 3) != name){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print("thread"+name+" ");
for(int i = 0; i < 5; i++){
System.out.print((num++)+" ");
}
System.out.println();
threadNum = (threadNum % 3) + 1;
this.notifyAll();
}
}
public static void main(String[] args) {
final MyThread thread = new MyThread();
for(int i = 0; i < 3; i++){
new Thread(""+i){
@Override
public void run() {
for (int j = 0; j < 4; j++) {
thread.fun();
}
}
}.start();
}
}
}
synchornized的使用场景以8个场景作为说明：
测试：
public class TestDemo8 {
public synchronized void fun1(){
System.out.println(Thread.currentThread().getName()+":: 同步方法fun1开始");
try {
TimeUnit.MILLISECONDS.sleep(1000);
// fun3();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":: 同步方法fun1结束");
}
public synchronized static void fun2() throws Exception {
//类锁 class对象
System.out.println(Thread.currentThread().getName()+":: 静态同步方法func2开始");
try {
TimeUnit.MILLISECONDS.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":: 静态同步方法func2结束");
}
public void fun3(){
System.out.println(Thread.currentThread().getName()+":: 非同步方法func3");
try {
TimeUnit.MILLISECONDS.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":: 非同步方法func3");
}
public synchronized void fun4(){
System.out.println(Thread.currentThread().getName()+":: 同步方法fun4开始");
try {
TimeUnit.MILLISECONDS.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":: 同步方法func4结束");
}
public static void main(String[] args) {
TestDemo8 test1 = new TestDemo8();
TestDemo8 test2 = new TestDemo8();
new Thread("A"){
@Override
public void run() {
test1.fun1(); //unlock
test1.fun3();
}
}.start();
new Thread("B"){
@Override
public void run() {
test1.fun1(); //lock
test1.fun3();
}
}.start();
// Thread threadc = new Thread("C"){
// @Override
// public void run() {
// test1.fun1();
// }
// };
// threadc.start();
// threadc.interrupt();
//
// new Thread("D"){
// @Override
// public void run() {
// test1.fun1();
// }
// }.start();
}
}常量池中多了ACC_SYNCHRONIZED标识符，标识当前的方法是一个同步方法，当方法 被调用，调用指令会检查方法ACC_SYNCHRONIZED标识符是否被设置，如果设置，执行线程会先去获取monitor，获取成功之后才会去执行方法体，方法体执行完成之后或释放monitor。
monitorenter 每一个对象都与一个monitor相关联，一个monitor的lock只能被一个线程在同一时间所 拥有，在一个线程尝试获取monitor的使用会发生以下事情：
在并发编程中有三大性质：
原子性我理解的就是它不是说只执行一条语句，一个动作就是原子性，相关它可以由一个或多个操作构成，但是，这些操作不能被分割，也就是说如果要执行的话，那么这一系列操作必须全部执行，如果不执行全部不执行，不能单独执行其中的某一个操作 ，将它给分割开。并且在执行过程中不会被其他因素给打断，妨碍执行。
借用一个经典的账户转账问题：
比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。
在并发编程中，比如有以下3个操作：
a = 10; //1
b = a; //2
b++; //3虽然看着好像都是只进行了一个操作，应该都属于原子性操作，但实际上只有1才满足原子性。2可以拆两步，先读取a的值，然后再将a赋值给b；3可以拆成3步，先读取b的值，然后计算b+1，再将b+1赋值给b。因为2,3都不满足原子性。
Tip：要想在多线程环境下保证原子性，则可以通过锁、synchronized来确保。volatile是无法保证复合操作的原子性。面试时经常会问到的比较synchronized和volatile，它们俩特性上最大的区别就在于原子性，volatile不具备原子性。
synchronized解锁之前，必须将工作内存中的数据同步到主内存，其它线程操作该变量时每次都可以看到被修改后的值。
举个例子：
threadA{
int test = 10;
test =20;
}
threadB{
int newTest = test;
}线程A终定义test为10，然后修改值为20,。线程B读取test的值赋值给newTest。 在执行线程A的test = 10时，先将test初始化并将10写入到cache中，然后执行test = 20，但此时20这个值并没有及时的刷新到主存中。因此当线程B访问test这个共享变量对newTest进行赋值时，读到的将会是初始值10，而不是最新的20，这样就会出现问题。
对于可见性，Java提供了volatile关键字来保证可见性。当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
先了解一个概念指令重排序：本来代码的执行过程应该和咱们书写的顺序一致，进行一个顺序执行，但是CPU和编译器为了提升程序执行的效率，会按照一定的规则进行指令优化，在保证执行结果不变的前提下更改指令的执行顺序。
在并发执行情况下，由于指令重排序的存在将会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。
volatile关键字保证可见性、有序性
volatile修饰的变量不会缓存到工作内存中，每一次读取获取最新volatile变量
Java内存不会对volatile指令进行重排序，从而保证对volatile的执行顺序永远是按照书写顺序执行的
在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
因此通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。
happens-before规则：Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，JVM可以随意地对它们进行重排序。
使用场景：
如单例模式双重验证锁机制来确保有序性：
class MySingleton{
private static volatile MySingleton singleton = null; //实例
private MySingleton(){}
public static MySingleton getInstance(){
if(singleton == null){
synchronized (MySingleton.class){
if(singleton == null){
singleton = new MySingleton();
}
}
}
return singleton;
}
}
volatile修饰的变量产生的汇编代码，会存在一个lock前缀，相当于一个内存屏障