多线程复习总结之解析Synchronized与重入锁

--流星。

已于 2022-04-17 17:09:17 修改

阅读量2.4k

点赞数

分类专栏：多线程文章标签： synchronized 重入锁多线程

于 2022-04-17 16:58:53 首次发布

本文链接：https://blog.csdn.net/weixin_45974176/article/details/123674951

版权

多线程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

引言

在Java里面，最基本的互斥同步手段就是synchronized关键字，常被人成为重量级锁，这是一种块结构（Block Structured）的同步语法。synchronized是Java语言中一个重量级的操作，有经验的程序员都只会在确实必要的情况下才使用这种操作。

同步：多线程排队，然后一个一个的访问

synchronized实现同步的基础

Java中的每一个对象都可以作为锁。具体表现为以下3种形式。

对于普通同步方法，锁是当前实例对象。（对象锁）
对于静态同步方法，锁是当前类的Class对象。（类锁）
对于同步方法块，锁是Synchonized括号里配置的对象。

synchronized的使用

public class Count implements Runnable {
    private static int sCount = 0;

    public static int getCount() {
        return sCount;
    }
//    @Override
//    public void run() {
//        for (int i = 0; i < 10000; i++) {
//            synchronized (this) {
//                sCount++;
//            }
//        }
//    }
    @Override
    public synchronized void run() {
        for (int i = 0; i < 10000; i++) {
            sCount++;
        }
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        Count count = new Count();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.print(Count.getCount());
    }
}

synchronized同步方法块的工作原理

1、synchronized关键字经过Javac编译之后，会在同步块的前后分别形成 monitorenter和monitorexit这两个字节码指令。这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。

如果Java源码中的synchronized明确指定了对象参数，那就以这个对象的引用作为reference；
如果没有明确指定，那将根据synchronized修饰的方法类型（如实例方法或类方法），来决定是取代码所在的对象实例还是取类型对应的Class对象来作为线程要持有的锁。

2、在执行monitorenter指令时，首先要去尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经持有了那个对象的锁，就把锁的计数器的值增加一。
3、在执行monitorexit指令时会将锁计数器的值减一。一旦计数器的值为零，锁随即就被释放了。
【注】如果获取对象锁失败，那当前线程就应当被阻塞等待，直到请求锁定的对象被持有它的线程释放为止。

synchronized容易犯的隐蔽错误

是否给同一个对象加锁
是否给错误的对象加锁

synchronized的特点

被synchronized修饰的同步块对同一条线程来说是可重入的。这意味着同一线程反复进入同步块也不会出现自己把自己锁死的情况。
被synchronized修饰的同步块在持有锁的线程执行完毕并释放锁之前，会无条件地阻塞后面其他线程的进入。这意味着无法像处理某些数据库中的锁那样，强制已获取锁的线程释放锁；也无法强制正在等待锁的线程中断等待或超时退出。

重入锁（ReentrantLock）

可重入：同一线程反复进入同步块也不会出现自己把自己锁死的情况。

重入锁（ReentrantLock）是Lock接口最常见的一种实现，它与synchronized一样是可重入的。

在基本用法上，ReentrantLock也与synchronized很相似，只是代码写法上稍有区别而已。不过，ReentrantLock与synchronized相比增加了一些高级功能，主要有以下三项：等待可中断、可实现公平锁及锁可以绑定多个条件。

等待可中断：是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。可中断特性对处理执行时间非常长的同步块很有帮助。
公平锁：是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的，ReentrantLock在默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。不过一旦使用了公平锁，将会导致ReentrantLock的性能急剧下降，会明显影响吞吐量。
锁绑定多个条件：是指一个ReentrantLock对象可以同时绑定多个Condition对象。在synchronized中，锁对象的wait()跟它的notify()或者notifyAll()方法配合可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外添加一个锁；而ReentrantLock则无须这样做，多次调用newCondition()方法即可。

重入锁的使用

基本的使用

class MyThread extends Thread {
    private ReentrantLock mLock = new ReentrantLock();

    @Override
    public void run() {
        super.run();

        mLock.lock();
        System.out.println("outside");

        mLock.lock();
        System.out.println("inside");
        mLock.unlock();

        mLock.unlock();
    }
}

可中断

class MyThread extends Thread {
    private ReentrantLock mLock = new ReentrantLock();

    @Override
    public void run() {
        super.run();

        try {
            mLock.lockInterruptibly();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if(mLock.isHeldByCurrentThread()){
                mLock.unlock();
            }
        }
    }
}

可设置等待时长

class MyThread extends Thread {
    private ReentrantLock mLock = new ReentrantLock();

    @Override
    public void run() {
        super.run();

        try {
            if (mLock.tryLock(2, TimeUnit.SECONDS)) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (mLock.isHeldByCurrentThread()) {
                mLock.unlock();
            }
        }
    }
}

可实现公平锁

class MyThread extends Thread {
    private ReentrantLock mLock;

    public MyThread(String name, ReentrantLock lock) {
        super(name);
        this.mLock = lock;
    }

    @Override
    public void run() {
        super.run();

        while (true) {
            mLock.lock();
            System.out.println(Thread.currentThread().getName() + "获得锁");
            mLock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock(true);
        MyThread t1 = new MyThread("t1", lock);
        t1.start();

        MyThread t2 = new MyThread("t2", lock);
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

synchronized的使用优势

既然重入锁和synchronized关键字的使用方式是一样的，而重入锁又比synchronized的功能高级，那为什么不推荐使用重入锁，而使用synchronized呢？

在synchronized与ReentrantLock都可满足需要时优先使用synchronized，理由如下：
1、synchronized是在Java语法层面的同步，足够清晰，也足够简单。每个Java程序员都熟悉synchronized，但J.U.C中的Lock接口则并非如此。因此在只需要基础的同步功能时，更推荐 synchronized。
2、Lock应该确保在finally块中释放锁，否则一旦受同步保护的代码块中抛出异常，则有可能永远不会释放持有的锁。这一点必须由程序员自己来保证，而使用synchronized的话则可以由Java虚拟机来确保即使出现异常，锁也能被自动释放。

扩展资料

1、对象锁和类锁

使用对象锁的三种方式：
1、锁住实体里的非静态变量
非静态变量是实例自身变量，不会与其他实例共享，所以锁住实体内声明的非静态变量可以实现对象锁。锁住同一个变量的方法块共享同一把锁。
2、锁住 this 对象
this 指的是当前对象实例本身，所以，所有使用 synchronized(this)方式的方法都共享同一把锁。
3、直接锁非静态方法
最简单、最直观的一种方式，直接加在方法返回类型前。

【注】使用对象锁的情况，只有使用同一实例的线程才会受锁的影响，多个实例调用同一方法也不会受影响。

使用类锁的三种方式：
1、锁住类中的静态变量
因为静态变量和类信息一样也是存在方法区的并且整个 JVM 只有一份，所以加在静态变量上可以达到类锁的目的。
2、直接在静态方法上加 synchronized
因为静态方法同样也是存在方法区的并且整个 JVM 只有一份，所以加在静态方法上可以达到类锁的目的。
3、锁住 xxx.class
对当前类的 .class 属性加锁，可以实现类锁。

【注】类锁是所有线程共享的锁，所以同一时刻，只能有一个线程使用加了锁的方法或方法体，不管是不是同一个实例。

2、synchronized修饰不同的对象

修饰方法：

synchronized修饰方法，该方法的flags中增加ACC_SYNCHRONIZED标记，有ACC_SYNCHRONIZED标记的方法在被调用时，调用指令先去检查方法的ACC_SYNCHRONIZED访问标志是否设置，如果设置了，执行线程先要持有同步锁，然后才能执行方法，否则相关线程会被阻塞。

修饰代码块：

synchronized修饰的代码块叫同步代码块，通常我们需要在synchronized()中指明进入同步代码块的key，这里的key可以是Object、this或者class

synchronized在修饰不同类型数据的时候，锁的粒度（互斥范围）也是不同的（这里只说最大粒度），简单总结就是：方法 > object
class > this。

this只会影响当前实例的线程访问；
class会影响当前类所有实例的线程访问；
object会影响所有访问同步代码的访问；
在方法上加synchronize关键字影响范围就更大了，会影响所有当前方法的访问。
所以，其中最重的就是修饰方法时候，其次是修饰object，然后才是class和this。

3、等待(wait)和通知(notify)

Object有两个很重要的方法：Object.wait()和Object.notify()

wait()：当在一个对象实例上调用了wait()，当前线程就会在这个对象上等待。
notifyAll()：它会唤醒所有正在等待这个对象的线程
notify()：只会随机唤醒一个等待该对象的线程

wait()、notify()和notifyAll()都需要在synchronized语句中使用:

class MyThread extends Thread {
    private Object mLock;

    public MyThread(Object lock) {
        this.mLock = lock;
    }

    @Override
    public void run() {
        super.run();

        synchronized (mLock) {
            try {
                mLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("in MyThread");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        MyThread t = new MyThread(lock);
        t.start();
        System.out.println("before sleep");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after sleep");

        synchronized (lock) {
            lock.notify();
        }
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}