首页 > 代码库 > Synchronized及其实现原理

Synchronized及其实现原理

2024-08-17 08:15:18   219人阅读

并发编程中synchronized一直是元老级角色，我们称之为重量级锁。主要用在三个地方：

1、修饰普通方法，锁是当前实例对象。

2、修饰类方法，锁是当前类的Class对象。

3、修饰代码块，锁是synchronized括号里面的对象。

一、synchronized实现原理

当一个线程试图访问同步代码块时，必须得到锁。在退出或抛出异常时必须释放锁，JVM是基于进入和退出Monitor来实现方法同步和代码块同步。

我们来看下synchronized的字节码：

public class SynchronizedTest
{
    public void addNum1(String userName)
    {
    }
    
    public void addNum2(String userName)
    {
        synchronized(this)
        {
        }
    }
    
    public synchronized void addNum3(String userName)
    {
    }
}

技术分享

在字节码里可以看到，用synchronizde修饰的同步代码块多了两个指令：monitorenter、monitorexit；

代码块同步是使用monitorenter、monitorexit指令实现的，而方法同步是使用另外一种方式实现的，但是方法同步也可以使用这两个指令来实现。

monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit是插入到方法的结束和异常位置。任何一个对象都有一个monitor与之关联。线程执行到monitorenter指令处时，会尝试获取对象所对应的monitor所有权，即尝试获得对象的锁。

二、修饰普通方法 锁是当前实例对象

我们先来看下将实例对象作为锁的概念：

public class AddNumTest
{
    private int num = 0;
    
    public synchronized void addNum(String str)
    {
        try
        {
            if ("a".equals(str))
            {
                num = 10;
                System.out.println("add a");
                Thread.sleep(2000);
            }
            else
            {
                num = 20;
                System.out.println("add b");
            }
            System.out.println(str + " num = " + num);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
public class AddNumThreadOne implements Runnable
{
    private AddNumTest at;
    
    public AddNumThreadOne(AddNumTest at)
    {
        this.at = at;
    }

    @Override
    public void run()
    {
        at.addNum("a");
    }
}
public class AddNumThreadTwo implements Runnable
{
    private AddNumTest at;
    public AddNumThreadTwo(AddNumTest at)
    {
        this.at = at;
    }
    
    @Override
    public void run()
    {
        at.addNum("b");
    }
}
public class AddNum
{
    public static void main(String[] args)
    {
        //注意，这里传入同一个实例对象
        AddNumTest at = new AddNumTest();
        //AddNumTest bt = new AddNumTest();
        Thread t1 = new Thread(new AddNumThreadOne(at));
        Thread t2 = new Thread(new AddNumThreadTwo(at));
        t1.start();
        t2.start();
    }
}

执行结果：

add a
a num = 10
add b
b num = 20

前面解释过关键字synchronized的实现原理是使用对象的monitor来实现的，取的锁都是对象锁，而不是把一段代码或者函数作为锁。在并发情况下，如果并发情况下多线程竞争的是同一个对象，那么先来的获取该对象锁，后面的线程只能排队，等前面的线程执行完毕释放锁。

上面介绍的是同一个对象锁，我们来观察下获取不同的对象锁会是什么情况：

public static void main(String[] args)
    {
        //注意，这里传入的不同的实例对象
        AddNumTest at = new AddNumTest();
        AddNumTest bt = new AddNumTest();
        Thread t1 = new Thread(new AddNumThreadOne(at));
        Thread t2 = new Thread(new AddNumThreadTwo(bt));
        t1.start();
        t2.start();
    }

执行结果：

add a
add b
b num = 20
a num = 10

这里线程1、2抢占的是不同的锁，尽管线程1先到达同步代码块的位置，但是由于monitor不一样，所以不能阻塞线程2的执行。

三、synchronized锁重入

锁重入：当一个线程得到一个对象锁后，再次请求此对象锁时可以再次得到该对象的锁。但是这里有维护一个计数器，同一个线程每次得到对象锁计数器都会加1，释放的时候减1，直到计数器的数值为0的时候，才能被其他线程所抢占

public class AgainLock
{
    public synchronized void print1()
    {
        System.out.println("do work print1");
        print2();
    }
    
    public synchronized void print2()
    {
        System.out.println("do work print2");
        print3();
    }
    
    public synchronized void print3()
    {
        System.out.println("do work print3");
    }
}
public class AgainLockTest
{
    public static void main(String[] args)
    {
        Thread t = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                AgainLock al = new AgainLock();
                al.print1();
            }
        });
        t.start();
    }
}

执行结果：

do work print1
do work print2
do work print3

这里面三个同步方法，使用的锁都是该实例对象的同步锁，同一个线程在执行的时候，每次都是在锁没有释放的时候，就要重新再去获取同一把对象锁。从运行结果可以看出，关键字synchronized支持同一线程锁重入。

四、synchronized同步代码块

用synchronized同步方法的粒度过大，有时候一个方法里面的业务逻辑很多，但是我们想对同步的部分进行单独定制，这时候就可以使用synchronized来同步代码块。

public class SynchronizedTest1
{
    public void doWorkTask()
    {
        for(int i=0;i<100;i++)
        {
            System.out.println("nosynchronized thread name =" + Thread.currentThread().getName()
                + ";i=" + i);
        }
        synchronized(this)
        {
            for(int i=0;i<100;i++)
            {
                System.out.println("thread name =" + Thread.currentThread().getName()
                    + ";i=" + i);
            }
        }
    }
}

如果在并发情况下，调用这个类的同一个实例，线程A和B可以同时执行使用synchronized同步之前的代码逻辑，但是使用关键字同步的部分是互斥的，先到达的线程占有对象锁，后面的线程会被阻塞，直到对象锁被前面的线程释放。

四、总结

synchronized是一种悲观锁：

1、多线程竞争的情况下，频繁的加锁解锁导致过多的线程上下文切换，由于java线程是基于操作系统内核线程实现的，所以如果阻塞或者唤醒线程都需要切换到内核态操作，这会极大的浪费CPU资源。

2、一个线程持有锁，会导致后面其他请求该锁的线程挂起。

synchronized锁优化：自旋锁

很多应用中共享数据的锁定，只会持续很短的时间，如果因为这很短的时间做线程的挂起和恢复，会造成很大的性能消耗（因为java线程对应操作系统的内核线程），让当前线程不停地的在循环体内执行不被挂起，这就是自旋锁的实现，后面会展开详细介绍。

 

Synchronized及其实现原理


联系
我们