synchronized关键字解析

概念

在并发编程中，多线程同时并发访问的资源叫做临界资源，当多个线程同时访问对象并要求操作相同资源时，分割了原子操作就有可能出现数据的不一致或数据不完整的情况，为避免这种情况的发生，我们会采取同步机制，以确保在某一时刻，方法内只允许有一个线程。

sychronized 用于 修饰 代码块、类的实例方法 & 静态方法

是利用锁的机制来实现同步的。

锁机制有如下两种特性：

**互斥性：**即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。

**可见性：**必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作从而引起不一致。

synchronized的用法

代码如下：

/**
* 对象锁
*/
public class Test{ 
    // 对象锁：形式1(方法锁) 
    public synchronized void Method1(){ 
        System.out.println("我是对象锁也是方法锁"); 
        try{ 
            Thread.sleep(500); 
        } catch (InterruptedException e){ 
            e.printStackTrace(); 
        } 
 
    } 
 
    // 对象锁：形式2（代码块形式） 
    public void Method2(){ 
        synchronized (this){ 
            System.out.println("我是对象锁"); 
            try{ 
                Thread.sleep(500); 
            } catch (InterruptedException e){ 
                e.printStackTrace(); 
            } 
        } 
 
    } 


/**
 * 方法锁（即对象锁中的形式1）
 */
    public synchronized void Method1(){ 
        System.out.println("我是对象锁也是方法锁"); 
        try{ 
            Thread.sleep(500); 
        } catch (InterruptedException e){ 
            e.printStackTrace(); 
        } 
 
    } 

/**
 * 类锁
 */

　　 // 类锁：形式1 ：锁静态方法
    public static synchronized void Method1(){ 
        System.out.println("锁静态方法"); 
        try{ 
            Thread.sleep(500); 
        } catch (InterruptedException e){ 
            e.printStackTrace(); 
        } 
 
    } 
 
    // 类锁：形式2 ：锁静态代码块
    public void Method2(){ 
        synchronized (Test.class){ 
            System.out.println("锁静态代码块"); 
            try{ 
                Thread.sleep(500); 
            } catch (InterruptedException e){ 
                e.printStackTrace(); 
            } 
 
        } 
 
    } 
}

使用synchronized注意的问题

• 与moniter关联的对象不能为空
• 尽量减小synchronized作用域范围
• 不能使用不同的monitor锁相同的方法
• 防止多个锁的交叉导致死锁

synchronized原理

采用 synchronized 修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个 monitor (锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

在 Java 中，每个对象有一把锁，叫对象锁，针对每个类也有一个锁，可以称为“类锁”，类锁实际上是通过对象锁实现的，即类的 Class 对象锁。每个类只有一个 Class 对象，所以每个类只有一个类锁。

底层依赖于 JVM ，通过一个监视器对象monitor完成， wait、notify 等方法也依赖于 monitor 对象监视器锁（monitor的本质 依赖于 底层操作系统的互斥锁Mutex Lock实现）

在 Java 中，每个对象都会有一个 monitor 对象，监视器。

• 某一线程占有这个对象的时候，先monitor 的计数器是不是0，如果是0还没有线程占有，这个时候线程占有这个对象，并且对这个对象的monitor+1；如果不为0，表示这个线程已经被其他线程占有，这个线程等待。当线程释放占有权的时候，monitor-1；
• 同一线程可以对同一对象进行多次加锁，+1，+1，重入性

我们先看一段简单的代码：

public class TestSynchronized {
    private int count;

    @Test
    public void test() throws InterruptedException {
        synchronized (this){
            count++;
        }
    }
}

现在我们反编译一下：

通过反编译后的代码我们可以知道synchronized修饰的代码块的加锁其实是通过monitorenter和monitorExit汇编指令配合使用的。在执行 count++ 指令之前，编译器加了一条 monitorenter 指令，count++ 指令执行结束时又加了一条 monitorexit 指令。准确意义上来说，这就是两条加锁的释放锁的指令。

除此之外，我们的 synchronized 方法在反编译后并没有这两条指令，但是编译器却在方法表的 flags 属性中设置了一个标志位 ACC_SYNCHRONIZED。这样，每个线程在调用该方法之前都会检查这个状态位是否为 1，如果状态为 1 说明这是一个同步方法，需要首先执行 monitorenter 指令去尝试获取当前实例对象的内置锁，并在方法执行结束执行 monitorexit 指令去释放锁。

JVM对synchronized的优化

synchronized锁住的代码块：同一时刻只能由一个线程访问，属于悲观锁

对象头与monitor

一个对象实例包含：对象头、实例变量、填充数据

偏向锁

在对象第一次被某一线程占有的时候，是否偏向锁置1，锁表01，写入线程号，当其他的线 程访问的时候，竞争，失败则升级为轻量级锁

CAS（campany and set）

竞争失败的时候，不是马上转化级别，而是执行几次空循环5 10

锁消除

JIT在编译的时候吧不必要的锁去掉