Java高并发编程基础synchronized及底层原理

Synchronized
1 synchronized关键字保证临界资源（多个线程共享的数据资源）同时只能被一个线程使用，保证共享数据操作的完整性，主要锁临界资源对象、this(当前对象）、class对象，Java中，每个对象都对应有一个可称为“互斥锁的标记”，这个标记保证在任一时刻，只能有一个线程访问改对象。

Object o = new Object();
	@Override
	public void run() {
		this.m();
	}
	public void m(){
		synchronized(o){
			System.out.println("锁临界资源对象");
		}
	}

1.1 锁当前对象，下面这种方式与synchronized(this)一样，都是锁住当前对象，加了synchronized关键字的方法称为同步方法

@Override
	public void run() {
		this.m();
	}
	public synchronized void m(){
			System.out.println("锁当前对象");
	}

1.2 当synchronized用在静态方法上或者静态常量，或者是synchronized(this.class)，锁的都是class对象，一个类，在内存中只有一个class对象。

public static synchronized void testSync4(){
		System.out.println(Thread.currentThread().getName() 
				+ " staticCount = " + staticCount++);
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static void testSync5(){
		synchronized(Test_02.class){
			System.out.println(Thread.currentThread().getName() 
					+ " staticCount = " + staticCount++);
		}
	}

1.3同步方法和非同步方法可以同时被调用，同步方法只影响锁定同一个对象的同步方法。不影响其他线程调用非同步方法，或调用其他锁资源的同步方法

public class Test_04 {
	Object o = new Object();
	public synchronized void m1(){ // 重量级的访问操作。
		System.out.println("public synchronized void m1() start");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.println("public synchronized void m1() end");
	}
	
	public void m3(){
		synchronized(o){
			System.out.println("public void m3() start");
			try {
				Thread.sleep(1500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("public void m3() end");
		}
	}
	
	public void m2(){
		System.out.println("public void m2() start");
		try {
			Thread.sleep(1500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("public void m2() end");
	}
	
	public static class MyThread01 implements Runnable{
		public MyThread01(int i, Test_04 t){
			this.i = i;
			this.t = t;
		}
		int i ;
		Test_04 t;
		public void run(){
			if(i == 0){
				t.m1();
			}else if (i > 0){
				t.m2();
			}else {
				t.m3();
			}
		}
	}
	
	public static void main(String[] args) {
		Test_04 t = new Test_04();
		new Thread(new Test_04.MyThread01(0, t)).start();
		new Thread(new Test_04.MyThread01(1, t)).start();
		new Thread(new Test_04.MyThread01(-1, t)).start();
	}
}

运行结果：
public synchronized void m1() start
public void m3() start
public void m2() start
public void m3() end
public void m2() end
public synchronized void m1() end

1.4 同步方法只能保证当前方法的原子性，不能保证多个业务方法之间的互相访问的原子性，注意在商业开发中，多方法要求结果访问原子操作，需要多个方法都加锁，且锁定统一个资源。

private double d = 0.0;
	public synchronized void m1(double d){
		try {
			// 相当于复杂的业务逻辑代码。
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.d = d;
	}
	
	public double m2(){
		return this.d;
	}
	
	public static void main(String[] args) {
		final Test_05 t = new Test_05();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m1(100);
			}
		}).start();
		System.out.println(t.m2());
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(t.m2());
	}

运行结果：0.0 100.0

1.5 synchronized为可重入的锁，可重入的意思是同一个线程的同步方法中，可以调用另一个锁相同对象的同步方法，

synchronized void m1(){ // 锁this
		System.out.println("m1 start");
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		m2();
		System.out.println("m1 end");
	}
	synchronized void m2(){ // 锁this
		System.out.println("m2 start");
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("m2 end");
	}
	
	public static void main(String[] args) {
		new Test_06().m1();
		
	}

1.6 synchronized的锁对象变更问题
同步代码一旦加锁后，那么会有一个临时的锁引用指向锁对象，和真实的引用无直接关联，也就是说锁住的是堆内存中的对象，比如synchronized(o),锁住的是堆内存中new出来的对象。在锁未释放之前，修改锁对象引用，不会影响同步代码的执行。

Object o = new Object();
	int i = 0;
	Object o1 = new Object();
	Object o2 = new Object();
	Object a(){
		try{
			/*
			 * return i ->
			 * int _returnValue = i; // 0;
			 * return _returnValue;
			 */
			return o1;//当try...catch...finally中，当catch中有return语句时，会将return语句压入栈，等finally执行完之后才会执行
		}finally{
			o1 = o2;
		}
	}
	
	void m(){
		System.out.println(Thread.currentThread().getName() + " start");
		synchronized (o) {//锁住的是堆中的对象
			while(true){
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + " - " + o);
			}
		}
	}
	
public static void main(String[] args) {
		final Test_13 t = new Test_13();
		new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "thread1").start();
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				t.m();
			}
		}, "thread2");
		t.o = new Object();//改变了对象，那么不会影响正在执行的线程，synchronized锁住的不是同一个对象了，这两个线程就不同步了
		thread2.start();
	}
	System.out.println(t.o1);  //o1
	System.out.println(t.a()); //o2,返回值并不是当前对象
	System.out.println(t.o1);  //o1

运行结果
thread1 - java.lang.Object@8dd897
thread1 - java.lang.Object@8dd897
java.lang.Object@2a139a55
java.lang.Object@2a139a55
java.lang.Object@15db9742
thread2 start
thread1 - java.lang.Object@e4a36f6
thread2 - java.lang.Object@e4a36f6 ，注意这里线程1和线程2打印的都是新的o
thread1 - java.lang.Object@e4a36f6
thread2 - java.lang.Object@e4a36f6…

1.7 synchronized 同步的缺点
synchronized关键字同步的时候，等待的线程将无法控制，只能死等。同步方法发生异常的时候会释放锁资源
synchronized关键字同步的时候，不保证公平性，因此会有线程插队的现象。
尽量在商业开发中避免同步方法。使用同步代码块。细粒度解决同步问题。

synchronized底层原理
Java 虚拟机中的同步(Synchronization)是基于进入和退出管程(Monitor)对象实现。
同步方法并不是由 monitor enter 和 monitor exit 指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。
对象内存简图
在这里插入图片描述
对象头：存储对象的 hashCode、锁信息或分代年龄或 GC 标志，类型指针指向对象的类元数据，JVM 通过这个指针确定该对象是哪个类的实例等信息。
实例变量：存放类的属性数据信息，包括父类的属性信息
填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐

当在对象上加锁时，数据是记录在对象头中。当执行 synchronized 同步方法或同步代码块时**，会在对象头中记录锁标记，锁标记指向的是 monitor 对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个 monitor 与之关联，对象与其 monitor 之间的关系有存在多种实现方式，如 monitor 可以与对象一起创建销毁或当线程试图获取对象锁时自动生成，但当一个 monitor 被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor 是由 ObjectMonitor 实现的。**
ObjectMonitor 中有两个队列，_WaitSet 和 _EntryList，以及 _Owner 标记。其中 _WaitSet 是用于管理等待队列(wait)线程的，_EntryList 是用于管理锁池阻塞线程的，_Owner 标记用于记录当前执行线程。线程状态图如下：
在这里插入图片描述
当多线程并发访问同一个同步代码时，首先会进入 _EntryList，当线程获取锁标记后，monitor 中的 _Owner 记录此线程，并在 monitor 中的计数器执行递增计算（+1），代表锁定，其他线程在 _EntryList 中继续阻塞。若执行线程调用 wait 方法，则monitor中的计数器执行赋值为0计算，并将 _Owner 标记赋值为 null，代表放弃锁，执行线程进如 _WaitSet 中阻塞。若执行线程调用 notify/notifyAll 方法，_WaitSet 中的线程被唤醒，进入 _EntryList 中阻塞，等待获取锁标记。若执行线程的同步代码执行结束，同样会释放锁标记，monitor中的 _Owner 标记赋值为 null，且计数器赋值为0计算。

上述资料来源尚学堂视频资料，如有侵权，请联系本人删除
上面原理个人感觉不是很全，于是本人又参考了其他大佬的博客，下面内容可以和上面的互补，加深理解

方法级的同步是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词），然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。

代码块的同步是利用monitorenter和monitorexit这两个字节码指令。它们分别位于同步代码块的开始和结束位置。当jvm执行到monitorenter指令时，当前线程试图获取monitor对象的所有权，如果未加锁或者已经被当前线程所持有，就把锁的计数器+1；当执行monitorexit指令时，锁计数器-1；当锁计数器为0时，该锁就被释放了。如果获取monitor对象失败，该线程则会进入阻塞状态，直到其他线程释放锁。

这里要注意：
synchronized是可重入的，所以不会自己把，自己锁死
synchronized锁一旦被一个线程持有，其他试图获取该锁的线程将被阻塞。

关于ACC_SYNCHRONIZED 、monitorenter、monitorexit指令，可以看一下下面的反编译代码:

public class SynchronizedDemo {
    public synchronized void f(){    //这个是同步方法
        System.out.println("Hello world");
    }
    public void g(){
        synchronized (this){		//这个是同步代码块
            System.out.println("Hello world");
        }
    }
    public static void main(String[] args) {

    }
}

使用javap -verbose SynchronizedDemo反编译后得到
在这里插入图片描述
我们看到对于同步方法，反编译后得到ACC_SYNCHRONIZED 标志，对于同步代码块反编译后得到monitorenter和monitorexit指令。
上述原理参考了大佬Medlen的博客

Mark Word
Mark Word在默认情况下存储着对象的HashCode、分代年龄、锁标记位等以下是32位JVM的Mark Word默认存储结构

锁状态	25bits	4bit	1bit是否是偏向锁	2bit 锁标志位
无锁状态	对象HashCode	对象分代年龄	0	01

Mark Word记录了对象和锁有关的信息，当这个对象被synchronized关键字当成同步锁时，围绕这个锁的一系列操作都和Mark Word有关。
Mark Word在32位JVM中的长度是32bit，在64位JVM中长度是64bit。
由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本，因此考虑到JVM的空间效率，Mark Word 被设计成为一个非固定的数据结构，以便存储更多有效的数据，它会根据对象本身的状态复用自己的存储空间，如32位JVM下，除了上述列出的Mark Word默认存储结构外，还有如下可能变化的结构：
在这里插入图片描述
其中无锁和偏向锁的锁标志位都是01，只是在前面的1bit区分了这是无锁状态还是偏向锁状态。

JDK1.6以后的版本在处理同步锁时存在锁升级的概念，JVM对于同步锁的处理是从偏向锁开始的，随着竞争越来越激烈，处理方式从偏向锁升级到轻量级锁，最终升级到重量级锁。

JVM一般是这样使用锁和Mark Word的：

1，当没有被当成锁时，这就是一个普通的对象，Mark Word记录对象的HashCode，锁标志位是01，是否偏向锁那一位是0。

2，当对象被当做同步锁并有一个线程A抢到了锁时，锁标志位还是01，但是否偏向锁那一位改成1，前23bit记录抢到锁的线程id，表示进入偏向锁状态。

3，当线程A再次试图来获得锁时，JVM发现同步锁对象的标志位是01，是否偏向锁是1，也就是偏向状态，Mark Word中记录的线程id就是线程A自己的id，表示线程A已经获得了这个偏向锁，可以执行同步锁的代码。

4，当线程B试图获得这个锁时，JVM发现同步锁处于偏向状态，但是Mark Word中的线程id记录的不是B，那么线程B会先用CAS操作试图获得锁，这里的获得锁操作是有可能成功的，因为线程A一般不会自动释放偏向锁。如果抢锁成功，就把Mark Word里的线程id改为线程B的id，代表线程B获得了这个偏向锁，可以执行同步锁代码。如果抢锁失败，则继续执行步骤5。

5，偏向锁状态抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程的线程栈中开辟一块单独的空间，里面保存指向对象锁Mark Word的指针，同时在对象锁Mark Word中保存指向这片空间的指针。上述两个保存操作都是CAS操作，如果保存成功，代表线程抢到了同步锁，就把Mark Word中的锁标志位改成00，可以执行同步锁代码。如果保存失败，表示抢锁失败，竞争太激烈，继续执行步骤6。

6，轻量级锁抢锁失败，JVM会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，尝试抢锁。从JDK1.7开始，自旋锁默认启用，自旋次数由JVM决定。如果抢锁成功则执行同步锁代码，如果失败则继续执行步骤7。

7，自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为10。在这个状态下，未抢到锁的线程都会被阻塞。
参考 Java的对象头和对象组成详解

本篇文章参考了多个大佬的博客，都已标记，如有侵权，请联系我删除，文中如有不对的地方，欢迎指正，谢谢！

ewenll

发布了11 篇原创文章 · 获赞 8 · 访问量 151

私信关注

Java高并发编程基础synchronized及底层原理

猜你喜欢