synchronize和mysql锁_synchronized的加锁方式与底层原理分析

1.synchronized的三种加锁方式

对于普通同步方法，锁是当前实例对象(对象锁)

在这种使用方式中，要注意锁是对象的实例，因为要保证多个线程使用的是同一个实例，否则仍然会有问题。

比如如下代码，因为每个线程的实例是不同的，因为他们获取的都不是同一把锁

public class Demo1 {

static int num = 0;

public synchronized void m1(){

for(int i=0;i<10000;i++){

num++;

}

}

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

Thread t2 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

Thread t3 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

t1.start();

t2.start();

t3.start();

t1.join();

t2.join();

t3.join();

System.out.println(num);

}

}

要想执行结果正确，就必须保证多个线程的实例是相同的，如下所示：

public class Demo1 {

static int num = 0;

public synchronized void m1(){

for(int i=0;i<10000;i++){

num++;

}

}

public static void main(String[] args) throws InterruptedException {

Demo1 demo1 = new Demo1();

Thread t1 = new Thread(()->demo1.m1());

Thread t2 = new Thread(()->demo1.m1());

Thread t3 = new Thread(()->demo1.m1());

t1.start();

t2.start();

t3.start();

t1.join();

t2.join();

t3.join();

System.out.println(num);

}

}

对于静态同步方法，锁是当前类Class对象(类锁)

public class Demo1 {

static int num = 0;

public synchronized static void m1(){

for(int i=0;i<10000;i++){

num++;

}

}

public static class T1 extends Thread{

@Override

public void run() {

Demo1.m1();

}

}

public static void main(String[] args) throws InterruptedException {

T1 t1 = new T1();

T1 t2 = new T1();

T1 t3 = new T1();

t1.start();

t2.start();

t3.start();

t1.join();

t2.join();

t3.join();

System.out.println(num);

}

}

对于同步方法块，锁是Synchronized括号里配置的对象

1.括号里的对象是class对象

public class Demo1 {

static int num = 0;

public void m1(){

// class对象锁

synchronized (Demo1.class){

for(int i=0;i<10000;i++){

num++;

}

}

}

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

Thread t2 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

Thread t3 = new Thread(()->{Demo1 demo1 = new Demo1();demo1.m1();});

t1.start();

t2.start();

t3.start();

t1.join();

t2.join();

t3.join();

System.out.println(num);

}

}

2. 括号里的对象是当前实例

public class Demo1 {

static int num = 0;

public void m1(){

// class对象锁

synchronized (this){

for(int i=0;i<10000;i++){

num++;

}

}

}

public static void main(String[] args) throws InterruptedException {

Demo1 demo1 = new Demo1();

Thread t1 = new Thread(()->demo1.m1());

Thread t2 = new Thread(()->demo1.m1());

Thread t3 = new Thread(()->demo1.m1());

t1.start();

t2.start();

t3.start();

t1.join();

t2.join();

t3.join();

System.out.println(num);

}

}

2.synchronized的实现原理

从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter和monitorexit指令实现的，而方法同步是使用另外一种方式实现的，细节在JVM规范里并没有详细说明。但是，方法的同步同样可以使用这两个指令来实现。

monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。

3.java对象头

在JVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。如下：

实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。

填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐，这点了解即可。

对象头：synchronized用的锁是存在Java对象头里的。如果对象是数组类型，则虚拟机用3个字宽(Word)存储对象头，如果对象是非数组类型，则用2字宽存储对象头。在32位虚拟机中，1字宽等于4字节，即32bit

Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。32位JVM的Mark Word的默认存储结构如表图所示：

在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变化为存储以下4种数据

在64位虚拟机下，Mark Word是64bit大小的，其存储结构如下图所示：

4.锁的三种状态

1.偏向锁

HotSpot的作者经过研究发现，大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1(表示当前是偏向锁)：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

2.轻量级锁

线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

3.重量级锁

内置锁在Java中被抽象为监视器锁(monitor)。在JDK 1.6之前，监视器锁可以认为直接对应底层操作系统中的互斥量(mutex)。这种同步方式的成本非常高，包括系统调用引起的内核态与用户态切换、线程阻塞造成的线程切换等。因此，后来称这种锁为“重量级锁”。

锁的优缺点的对比：

5.synchronized的可重入性

从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功， 在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。如下：

public class AccountingSync implements Runnable{

static AccountingSync instance=new AccountingSync();

static int i=0;

static int j=0;

@Override

public void run() {

for(int j=0;j<1000000;j++){

//this,当前实例对象锁

synchronized(this){

i++;

increase();//synchronized的可重入性

}

}

}

public synchronized void increase(){

j++;

}

public static void main(String[] args) throws InterruptedException {

Thread t1=new Thread(instance);

Thread t2=new Thread(instance);

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println(i);

}

}

正如代码所演示的，在获取当前实例对象锁后进入synchronized代码块执行同步代码，并在代码块中调用了当前实例对象的另外一个synchronized方法，再次请求当前实例锁时，将被允许，进而执行方法体代码，这就是重入锁最直接的体现，需要特别注意另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的，因此每次重入，monitor中的计数器仍会加1。

6.synchronized与等待唤醒机制

所谓等待唤醒机制本篇主要指的是notify/notifyAll和wait方法，在使用这3个方法时，必须处于synchronized代码块或者synchronized方法中，否则就会抛出IllegalMonitorStateException异常，这是因为调用这几个方法前必须拿到当前对象的监视器monitor对象，也就是说notify/notifyAll和wait方法依赖于monitor对象，在前面的分析中，我们知道monitor 存在于对象头的Mark Word 中(存储monitor引用指针)，而synchronized关键字可以获取 monitor ，这也就是为什么notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法调用的原因。

synchronized (obj) {

obj.wait();

obj.notify();

obj.notifyAll();

}

需要特别理解的一点是，与sleep方法不同的是wait方法调用完成后，线程将被暂停，但wait方法将会释放当前持有的监视器锁(monitor)，直到有线程调用notify/notifyAll方法后方能继续执行，而sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后，并不会马上释放监视器锁，而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。

7.synchronized与中断机制

事实上线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用，也就是对于synchronized来说，如果一个线程在等待锁，那么结果只有两种，要么它获得这把锁继续执行，要么它就保存等待，即使调用中断线程的方法，也不会生效。演示代码如下：

public class SynchronizedBlocked implements Runnable{

public synchronized void f() {

System.out.println("Trying to call f()");

while(true) // Never releases lock

Thread.yield();

}

/**

* 在构造器中创建新线程并启动获取对象锁

*/

public SynchronizedBlocked() {

//该线程已持有当前实例锁

new Thread() {

public void run() {

f(); // Lock acquired by this thread

}

}.start();

}

public void run() {

//中断判断

while (true) {

if (Thread.interrupted()) {

System.out.println("中断线程!!");

break;

} else {

f();

}

}

}

public static void main(String[] args) throws InterruptedException {

SynchronizedBlocked sync = new SynchronizedBlocked();

Thread t = new Thread(sync);

//启动后调用f()方法,无法获取当前实例锁处于等待状态

t.start();

TimeUnit.SECONDS.sleep(1);

//中断线程,无法生效

t.interrupt();

}

}

以上内容为自己学习时所记录的笔记，主要来源于以下资料：

1.java并发编程的艺术

2.http://www.itsoku.com/article/168