Java之加互斥锁_为对象加互斥锁

哪个关键字可以对对象加互斥锁？（A）
A synchronized
B volatile
C serialize
D static

synchronized的4种用法

1. 方法声明时使用，放在范围操作符(public等之后)，返回类型声明(void等)之前，这时，线程获得的是成员锁，即一次只有一个线程进入该方法，其他线程要想再此时调用该方法，只能排队等候，当前线程(就是在synchronized方法内部的线程)执行完该方法后，别的线程才能进入。

public synchronized void synMethod(){
//方法体
}
1
2
3

2. 对某一代码块使用，synchronize后跟括号，括号里面是变量，这样一次只有一个线程进入该代码块，此时，线程获得的是成员锁

public int synMethod(int a){
    synchronized(a){
        //一次只有一个线程进入
    }
}
1
2
3
4
5

1. synchronized后面括号里是一对象，此时，线程获得的是对象锁。例子：经典的多窗口卖票问题就可以采用此方法使用synchronized进行上锁

public class Ticket {
    private int num = 100;

    //卖票过程
    public void saleTicket(){
        synchronized (this) {
            if (num > 0) {
                //模拟出票
                try {
                    Thread.sleep((int) (Math.random() * 100));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //卖票
                System.out.println(Thread.currentThread().getName() + "售出" + num-- + "号票");
                //System.out.println(Thread.currentThread().getName() + "出票完成");
            } /*else {
                System.out.println("售完");
            }*/
        }
    }

    public int getNum() {
        return num;
    }
}

public class TicketTread implements Runnable{
    private  Ticket ticket;

    //构造方法使得三个线程运行同一个Ticket对象
    public TicketTread(Ticket ticket) {
        this.ticket = ticket;
    }

    @Override
    public void run() {
        while (ticket.getNum() > 0){
            ticket.saleTicket();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

对于方法3，如果线程进入，则得到当前对象锁，那么别的线程在该类所有对象上的任何操作都不能进行，在对象级使用锁通常是一种比较粗糙的方法。

如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁

class FineGrainLock {
 
   MyMemberClass x, y;
   Object xlock = new Object(), ylock = new Object();
 
   public void foo() {
      synchronized(xlock) {
         //xlock对象使用的资源的代码块
      }
 
      //可以在此进行一部分操作，但不要使用共享资源
 
      synchronized(ylock) {
         //ylock对象使用的资源代码块
      }
   }
 
   public void bar() {
      synchronized(this) {
         //xlock和ylock共享资源使用时，写到这部分
      }
      //可以在此进行一部分操作，但不要使用共享资源
   }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4. synchronized后面括号里是类，此时，线程获得的是对象锁。如果线程进入，则线程在该类中所有操作不能进行，包括静态变量和静态方法的代码块的同步，通常用此方法加锁。

Volatile原理

先行知识：

在进行多线程编程时能够保证程序执行的正确性，JVM内存模型为我们提供了1.原仔细、2.可见性、3.有序性。

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

happens-before原则(先行发生原则)：

• 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作。
• 锁定规则：一个unlock操作先行发生于后面对同一个锁unlock操作。
• volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作。
• 传递规则：如果操作A先行发生于操作B，而操作B又先行操作C，则可以得出操作A先行发生于操作C。
• 线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作
• 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
• 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，可以通过Thread.join()方法结束
• 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

volatile

用来确保将变量的更新操作通知到其他线程, 当把变量声明为volatile类型后, 编译器与运行时都会注意到这个变量是共享的, 因此不会将该变量上的操作与其他内存操作一起重排序. 然而, 在访问volatile变量时, 不会执行加锁操作, 因此也就不会使执行线程阻塞, 因此, volatile变量是一种比synchronized关键字更轻量级的同步机制。

深入剖析

1. volatile关键字的两层语义
   一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后，那么就具备了两层语义：
   1. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
   2. 禁止进行指令重排序

volatile修饰之后变得不一样了：

1. 使用volatile关键字会强制将修改的值立即写入主存;
2. 使用volatile关键字的话，当线程进行修改时，会导致线程1的工作内存中缓存stop的缓存行无效(反应到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效);
3. 由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值会去主存读取。

volatile不能保证原子性，能保证可见性，在一定程度上保证有序性，原因：volatile关键字禁止指令重排序。
volatile关键字禁止指令重排序有两层意思：

1. 当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定肯定还没有进行；
2. 在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能volatile变量后面的语句放在其前面执行。

volatile的原理和实现机制

volatile的原理和实现机制

前面讲述了源于volatile关键字的一些使用，下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。

下面这段话摘自《深入理解Java虚拟机》：

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

2）它会强制将对缓存的修改操作立即写入主存；

3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

使用volatile关键字的场景

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

1）对变量的写操作不依赖于当前值

2）该变量没有包含在具有其他变量的不变式中

实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

本文转载参考文章：java面试题6 牛客:哪个关键字可以对对象加互斥锁？
原文链接：https://blog.csdn.net/weixin_43392489/article/details/102677511