Java内置锁——synchronized

最新推荐文章于 2022-04-11 11:26:11 发布

圣斗士Morty

最新推荐文章于 2022-04-11 11:26:11 发布

阅读量311

点赞数

分类专栏： Java多线程与并发文章标签： synchronized 多线程并发锁面试

本文链接：https://blog.csdn.net/u014745069/article/details/82120244

版权

Java多线程与并发专栏收录该内容

21 篇文章 7 订阅

订阅专栏

一、给对象加把锁

synchronized关键字是Java唯一内置的互斥锁，通过关键字 synchronized 可以保证同一时刻只有一个线程获得某个同步代码块的执行权，但不会导致其他线程执行非同步方法时阻塞。

当获得锁的线程执行完同步代码块后，线程会将锁释放，其他由于锁占用导致阻塞的线程可以通过非公平的方式（非公平指的是获得锁的操作不是按照请求锁的顺序，即没有先来后到之分）获得锁，并进入同步代码块执行代码。

虽然我们通常要在方法上或是为某个代码块标记 synchronized，但实际上，JVM实现锁的逻辑是通过给对象加锁。

如果将一个成员方法标记为synchronized，那么执行这个方法时就需要给当前对象 this 加锁。对象只有一个，而synchronized方法可能有多个，因此，如果某个线程已经获得了这把锁，那么就意味着其他线程不仅没有权限执行当前方法，就连其他同步方法也无法执行，因为这些同步方法都需要获得同一个对象锁。

想要证明是锁对象其实非常简单，下面这个demo可以看出synchronized锁定的是同一个共享对象，而不是这个对象的某一个加锁方法。

import java.util.concurrent.TimeUnit;

/**
 * 此例证明了synchronized锁是锁定的对象而不是代码片段 <br>
 * 类名：ObjectLockDemo<br>
 * 作者： mht<br>
 * 日期： 2018年8月27日-下午1:25:47<br>
 */
public class ObjectLockDemo {

    public static void main(String[] args) {
        T t = new T();
        new Thread(() -> t.doSomthing(), "t1").start();
        new Thread(() -> t.doOtherthing(), "t2").start();
    }
}

class T {
    synchronized void doSomthing() {
        System.out.println(Thread.currentThread().getName() + " do something start...");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " do something end...");
    }

    synchronized void doOtherthing() {
        System.out.println(Thread.currentThread().getName() + " do otherthing...start");
        System.out.println(Thread.currentThread().getName() + " do otherthing...end");
    }
}

上面这个例子非常简单。首先，我们为T类创建了两个加锁的方法doSomthing()和doOtherthing()，在主线程中，我们创建了一个 t 对象，然后通过线程 t1 调用 对象 t 的doSomthing()加锁方法，紧接着线程 t2 去调用 对象 t 的另一个加锁方法doOtherthing()，如果synchronized锁住的是方法，那么在 t1 执行的5秒内，t2 可以自由的执行doOtherthing()方法而不受限制，但是如果是锁住了对象那么线程 t2 只有当 t1 执行完成后释放了对象锁，才能去执行 doOtherthing()方法，也就证明了synchronized锁住的是 t 对象。

执行结果如下，很明显，t2 等到 t1 完成后才执行了线程，synchronized锁住的是对象。

二、synchronized用法

synchronized不论如何使用，都是直接锁住了对象，但是在写法上，却存在很多变式：

用法一：

public class A {
    private Object o = new Object();
    private int count = 10;
    public void m() {
        synchronized (o) {// 任何线程若想执行代码块中的语句，必须先拿到o的锁
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}

用法二：

public class A {
    private int count = 10;
    public void m() {
        synchronized (this) {// 任何线程若想执行代码块中的语句，必须先拿到this的锁
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}

synchronized锁定的是一个对象，任何代表对象的事物都可以作为synchronized参数。

用法三：

public class A {
    private int count = 10;
    public synchronized void m() { // 等同于在方法的代码执行时要synchronized(this)
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
}

上面代码就是平时比较常见的加锁方式，虽然synchronized修饰了方法，但是一定不能理解为锁定了代码块，而是执行这段代码的当前对象 this

用法四（修饰静态方法）：

public class A {
    private static int count = 10;
    public synchronized static void m() { // 这里相当于synchronized(thingking.com.A.class)
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    
    public static void mm() {
        synchronized (A.class) {// 这是不可以写this，this指代对象，而静态方法是通过类来调用的，没有this对象
            count--;
        }
    }
}

三、互斥锁的重入性

作为一种互斥锁，synchronized可以避免并发情景下的线程乱入问题，保证了同步代码块的顺序执行。

重入性指的是，允许同一个线程重复获得已经获得的锁，不会造成阻塞，即重复进入同步代码块。重入性是互斥锁的一个重要特性，如果在同步代码块中又调用了该对象的其他同步方法，那么就会出现当前线程需要反复获取锁的情况，如果锁不允许同一个线程重入，就会出现“我拿不到我自己占用的锁”的尴尬情况，最终导致死锁！

public class T {
    synchronized void m() {
        System.out.println("m start...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m end...");
    }

    public static void main(String[] args) {
        new TT().m();
    }
}

class TT extends T {
    @Override
    synchronized void m() {
        System.out.println("child m start...");
        super.m();
        System.out.println("child m end...");
    }
}

上述代码是重入性的一种典型应用，子类中的同步方法调用父类中的同步方法，也是允许重入的。当调用子类的同步方法时，实际上锁定的是this，而子类的对象同样也可以看做是一个父类对象，因此这个锁是允许重入的，不会造成死锁。

执行结果：

四、注意异常

在默认情况下，synchronized锁在发生异常时会自动释放锁。所以在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。

比如，在一个web app处理过程中，多个servlet 线程共同访问同一个资源，这是如果如果异常处理不合适，在第一个线程中抛出异常，其他线程会进入同步代码块，有可能会访问到异常产生的数据，因此要非常小心的处理同步业务逻辑中的异常。

public class T {
    int count = 0;
    synchronized void m() {
        System.out.println(Thread.currentThread().getName() + " start...");
        while (true) {
            count++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                int i = 1 / 0;// 此处抛出异常，锁将被释放，要想不释放，可以在这里进行catch，然后让循环继续
            }
        }
    }

    public static void main(String[] args) {
        T t = new T();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                t.m();
            }
        };
        new Thread(r, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(r, "t2").start();
    }
}

执行结果：