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

引言

在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++;
//            }
//        }
//    }@Overridepublic 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();@Overridepublic 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();@Overridepublic 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();@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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();}}
}

附：参考链接

详解synchronized关键字
Java多线程 - 各种线程锁

多线程复习总结之解析Synchronized与重入锁相关推荐

java lock可重入_Java源码解析之可重入锁ReentrantLock
本文基于jdk1.8进行分析. ReentrantLock是一个可重入锁,在ConcurrentHashMap中使用了ReentrantLock. 首先看一下源码中对ReentrantLock的介绍. ...
synchronized可重入锁
什么是可重入锁?它有什么作用? 可重入锁,也叫做递归锁,指的是在同一线程内,外层函数获得锁之后,内层递归函数仍然可以获取到该锁. 说白了就是同一个线程再次进入同样代码时,可以再次拿到该锁. 它的作用是 ...
JUC - 多线程之悲观锁、乐观锁，读写锁（共享锁、独享锁），公平非公平锁，可重入锁，自旋锁，死锁（十）
Java中主要有如下锁一.悲观锁.乐观锁悲观锁:当前线程去操作数据的时候,总是认为别的线程会去修改数据,所以每次操作数据的时候都会上锁,别的线程去操作数据的时候就会阻塞,比如synchronize ...
java中的账户冻结原理_java可重入锁(ReentrantLock)的实现原理
前言相信学过java的人都知道 synchronized 这个关键词,也知道它用于控制多线程对并发资源的安全访问,兴许,你还用过Lock相关的功能,但你可能从来没有想过java中的锁底层的机制是怎么 ...
到底什么是重入锁，拜托，一次搞清楚！
相信大家在工作或者面试过程中经常听到重入锁这个概念,或者与关键字 synchrozied 的对比,栈长面试了这么多人,80%的面试者都没有答对或没有答到点上,或者把双重效验锁搞混了,哭笑不得.. 那么 ...
6※、线程同步、同步锁、同步代码块的使用、同步锁释放的时机、ReentrantLock可重入锁、公平锁与非公平锁的区别、什么是死锁、线程间的通信（生产者和消费者模式）
线程锁 1.※线程的同步:(要确保对象锁是一致的) 1.未使用同步锁的抢票 2.使用了同步锁的抢票 3.线程-同步代码块的使用 4.同步方法和代码块的区别 5.同步锁释放的时机练习:多线程生产手机 ...
可重入锁介绍以及原理
可重入锁介绍首先,在Synchronized和ReentrantLock的区别中,我们介绍了两者都是可重入锁,那么究竟什么是可重入锁呢?其内部原理又是如何实现的呢? 概念:可重入锁意味着:若一个程序 ...
Java面试之锁-可重入锁和递归锁
可重入锁和递归锁ReentrantLock 概念可重入锁就是递归锁指的是同一线程外层函数获得锁之后,内层递归函数仍然能获取到该锁的代码. 在同一线程在外层方法获取锁的时候,在进入内层方法会自动获取 ...
可重入锁和不可重入锁详解
目录概念: 通俗理解: 可重入锁的工作原理: ReenTrantLock可重入锁和synchronized的区别: ReentrantLock源码分析: 可重入锁代码演示: 概念: Reentran ...

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

引言

synchronized实现同步的基础

synchronized的使用

synchronized同步方法块的工作原理

synchronized容易犯的隐蔽错误

synchronized的特点

重入锁（ReentrantLock）

重入锁的使用

基本的使用

可中断

可设置等待时长

可实现公平锁

synchronized的使用优势

扩展资料

1、对象锁和类锁

2、synchronized修饰不同的对象

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

附：参考链接

多线程复习总结之解析Synchronized与重入锁相关推荐

最新文章

热门文章