聊聊synchronized

最新推荐文章于 2021-06-27 20:51:19 发布

mao939101699

最新推荐文章于 2021-06-27 20:51:19 发布

阅读量118

点赞数

文章标签： java 后端

本文链接：https://blog.csdn.net/u011455706/article/details/104446242

版权

在涉及到多线程的场景下，不可避免地会想到synchronized关键字。synchronized主要是为了线程安全而使用的，大致可以分为两种情况 1）.类锁;2）.实例对象锁.。

类锁

利用类加锁，一般加了类锁的方法或者方法块，一次只有一个线程可以调用该方法或者方法块。下面是代码部分

public class Main {

    public static void main(String[] args) {
        Main m = new Main();
        new Thread(new Runnable() {
            @Override
            public void run() {
                m.method1();
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                m.method2();
            }
        },"B").start();

    }

    private void method1() {
        synchronized (Main.class) {
            for (int i = 0;i<3;i++) {
                System.out.println("Thread name : " + Thread.currentThread().getName()+" method1");
            }
        }
    }

代码中开启了两个线程，每个线程中都调用了method1方法，该方法执行前都要先获取Main.class这个类锁。一旦其中一个线程获得了类锁，那么另外一个线程就会阻塞，等待当前线程释放这个类锁。执行结果如下：

Thread name : A method1
Thread name : A method1
Thread name : A method1
Thread name : B method1
Thread name : B method1
Thread name : B method1

Process finished with exit code 0

从执行结果看，线程A先获得了类锁，当线程A释放了类锁，线程B获得类锁后，才能执行方法method1。

实例对象锁

利用实例对象进行加锁。如果这个对象不是单例的，那么就会存在这个类的多个实例对象。需要线程安全的方法或者方法块，如果不是对同一个实例对象加锁，那么就无法保证线程安全、先看下下面这段代码：

public static void main(String[] args) {
    Main m = new Main();
    new Thread(new Runnable() {
        @Override
        public void run() {
            m.method2();
        }
    },"A").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            m.method2();
        }
    },"B").start();

}

private void method2() {
    Object o = new Object();
    synchronized (o) {
        for (int i = 0;i<3;i++) {
            System.out.println("Thread name : " + Thread.currentThread().getName()+" method2");
        }
    }
}

同样还是两个线程，调用同一个方法method2，每次调用时都会新生产一个Object对象，然后对这个对象加锁执行同步方法块，先看执行结果：

Thread name : A method2
Thread name : B method2
Thread name : A method2
Thread name : B method2
Thread name : A method2
Thread name : B method2

从执行结果看，这个同步方法块没有实现线程安全，因为每次进入方法后，都是以新的一个实例对象作为锁。两个线程就是两个实例对象，当然也就无法达到线程安全的目的、下面把代码修改下，如下：

private Object o = new Object();
public static void main(String[] args) {
    Main m = new Main();
    new Thread(new Runnable() {
        @Override
        public void run() {
            m.method2();
        }
    },"A").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            m.method2();
        }
    },"B").start();
}

private void method2() {
    synchronized (o) {
        for (int i = 0;i<3;i++) {
            System.out.println("Thread name : " + Thread.currentThread().getName()+" method2");
        }
    }
}

执行结果如下：

Thread name : A method2
Thread name : A method2
Thread name : A method2
Thread name : B method2
Thread name : B method2
Thread name : B method2

Process finished with exit code 0

修改后的代码以类的一个私有变量作为锁，每次要执行同步方法块是先获取这个私有变量作为锁，因为是同一个实例，所以当其中一个线程获得锁时，另外一个线程有需要等待，直到另外一个线程释放锁。

在jdk1.6以前，synchronized是个重量级锁，开销比较大。不过在jdk1.6以后，synchronized作了优化，synchronized会根据线程锁竞争情况进行演变。

偏向锁

当只有一个线程执行同步方法或者同步方法块（有些文章也称为临界区）时，这个对象锁会演变成偏向锁，所谓偏向锁即这个锁偏向于第一次获取该锁的线程。被偏向的这个线程在获取锁时没有额外的消耗。

轻量级锁

如果此时有另外一个线程也要执行同步方法块，这时候就有了锁的竞争，偏向锁就会演变会轻量级锁，锁演变的过程称为锁的膨胀。轻量级锁主要有自旋锁和自适应自旋锁。自旋是指锁在等待获取锁的过程中，不是阻塞在那里，而是原地循环等待，相当于在执行空的循环。如果自旋了很久都没有获取到锁，会比较浪费CPU资源，因此当自旋锁自旋超过一定次数（默认10次），自旋锁就会演变会重量级锁。而自适应锁自旋锁是指自旋次数会动态的改变。比如一个获取过自旋锁的线程再次来获取自旋锁时，jvm会认为该线程能再次成功获得该锁，会增加锁自旋的次数。

轻量级锁主要用于同步代码块执行很快的场景，这样线程等待较短的时间就能获取到锁。轻量级锁也常被称为非阻塞同步锁、乐观锁，因为在锁竞争的过程中，线程没有被阻塞而是在循环等待。

重量级锁

当轻量级锁再次膨胀时，就演变成了重量级锁，一般出现在多个线程竞争锁的场景下。重量级锁依赖操作系统的互斥锁，所以重量级锁也被称为互斥锁，也称为同步阻塞锁、悲观锁。重量级锁开销比较大，因为阻塞和唤醒线程需要操作系统介入，这就需要操作系统从用户态切换到内核态，而这切换时很消耗时间。

本文主要讲述了synchronized关键字的使用以及由synchroniezd设定的锁是如何根据不同的场景进行演变，不足之处希望指出，大家多多交流！