哪个关键字可以对对象加互斥锁?(A)
A synchronized
B volatile
C serialize
D static
synchronized的4种用法
- 方法声明时使用,放在范围操作符(public等之后),返回类型声明(void等)之前,这时,线程获得的是成员锁,即一次只有一个线程进入该方法,其他线程要想再此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入。
public synchronized void synMethod(){
//方法体
}
- 对某一代码块使用,synchronize后跟括号,括号里面是变量,这样一次只有一个线程进入该代码块,此时,线程获得的是成员锁
public int synMethod(int a){
synchronized(a){
//一次只有一个线程进入
}
}
- 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();
}
}
}
对于方法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共享资源使用时,写到这部分
}
//可以在此进行一部分操作,但不要使用共享资源
}
}
- 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关键字更轻量级的同步机制。
深入剖析
- volatile关键字的两层语义
一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:- 保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。
- 禁止进行指令重排序
volatile修饰之后变得不一样了:
- 使用volatile关键字会强制将修改的值立即写入主存;
- 使用volatile关键字的话,当线程进行修改时,会导致线程1的工作内存中缓存stop的缓存行无效(反应到硬件层的话,就是CPU的L1或者L2缓存中对应的缓存行无效);
- 由于线程1的工作内存中缓存变量stop的缓存行无效,所以线程1再次读取变量stop的值会去主存读取。
volatile不能保证原子性,能保证可见性,在一定程度上保证有序性,原因:volatile关键字禁止指令重排序。
volatile关键字禁止指令重排序有两层意思:
- 当程序执行到volatile变量的读操作或者写操作时,在其前面的操作的更改肯定全部已经进行,且结果已经对后面的操作可见;在其后面的操作肯定肯定还没有进行;
- 在进行指令优化时,不能将在对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