关键字synchronized与volatile详解

最新推荐文章于 2024-09-10 15:09:14 发布

Van-bo

最新推荐文章于 2024-09-10 15:09:14 发布

阅读量1.3w

点赞数 1

分类专栏：多线程

本文链接：https://blog.csdn.net/qq_41573860/article/details/113807508

版权

多线程专栏收录该内容

12 篇文章 1 订阅

订阅专栏

在多线程并发编程中synchronized和volatile都扮演着重要的角色，synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。而volatile是轻量级的 synchronized，它在多处理器开发中保证了共享变量的“可见性”。

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个场景作为说明：

两个线程同时访问同一个对象的同步方法安全
两个线程同时访问两个对象的同步方法不安全 test1.func1() test2.func1()
两个线程同时访问(一个或两个)对象的静态同步方法安全
两个线程分别同时访问(一个或两个)对象的同步方法和非同步方法不安全
两个线程访问同一个对象中的同步方法，同步方法又调用另外一个非同步方法不安全
两个线程同时访问同一个对象的不同的同步方法安全
两个线程同时访问静态synchronized和非静态synchornized方法不安全
同步方法抛出异常，JVM会自动释放锁

测试：

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();
    }
}

底层原理

1.同步方法

常量池中多了ACC_SYNCHRONIZED标识符，标识当前的方法是一个同步方法，当方法被调用，调用指令会检查方法ACC_SYNCHRONIZED标识符是否被设置，如果设置，执行线程会先去获取monitor，获取成功之后才会去执行方法体，方法体执行完成之后或释放monitor。

2.同步代码块

monitorenter 每一个对象都与一个monitor相关联，一个monitor的lock只能被一个线程在同一时间所拥有，在一个线程尝试获取monitor的使用会发生以下事情：

如果monitor的entry count为0，意味monitor的lock还没有被获取，某个线程获取之后会对entry count+1，从此该线程就是这个monitor的所有者了
如果一个已经拥有该monitor使用权的线程再次进入，会导致monitor的entry count+1 (可重入锁)
如果monitor已经被其他线程所拥有，其他线程尝试获取该monitor的额所有权时，会被陷入阻塞，直到monitor的entry count为0，才能再次尝试去获取monitorexit 释放对monitor的使用权，要释放对某个对象的monitor的使用权前提是首先获取该monintor的所有权，将monitor的entry count-1，如果entry count为0，那就表示该线程不再拥有该monitor的使用

三大性质

在并发编程中有三大性质：

1.原子性

原子性我理解的就是它不是说只执行一条语句，一个动作就是原子性，相关它可以由一个或多个操作构成，但是，这些操作不能被分割，也就是说如果要执行的话，那么这一系列操作必须全部执行，如果不执行全部不执行，不能单独执行其中的某一个操作，将它给分割开。并且在执行过程中不会被其他因素给打断，妨碍执行。

借用一个经典的账户转账问题：

比如从账户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不具备原子性。

2.可见性

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能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

3.有序性

先了解一个概念指令重排序：本来代码的执行过程应该和咱们书写的顺序一致，进行一个顺序执行，但是CPU和编译器为了提升程序执行的效率，会按照一定的规则进行指令优化，在保证执行结果不变的前提下更改指令的执行顺序。

在并发执行情况下，由于指令重排序的存在将会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。

Violate

使用机制

volatile关键字保证可见性、有序性

1）保持内存可见性

volatile修饰的变量不会缓存到工作内存中，每一次读取获取最新volatile变量

2）禁止指令重排序

Java内存不会对volatile指令进行重排序，从而保证对volatile的执行顺序永远是按照书写顺序执行的

在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

因此通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

happens-before规则：Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，JVM可以随意地对它们进行重排序。

使用场景：

boolean标志位
单例模式双重检测锁

如单例模式双重验证锁机制来确保有序性：

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;
    }
}