B4. Concurrent JVM 锁机制（synchronized）

https://www.cnblogs.com/zlxyt/p/11050346.html

挺好的 感觉这个文章写的 不过想要提高 还是得自己写代码 不写代码 肯定不行.

【概述】

　　JVM 通过 synchronized 关键字提供锁，用于在线程同步中保证线程安全。

【synchronized 实现原理】

　　synchronized 可以用于代码块或者方法中，产生同步代码区域，也叫互斥区。互斥区每次只能允许一个线程进入执行同步代码或重新进入执行剩余同步代码（参考线程进入等待状态后会唤醒，然后进入阻塞状态，重新获得锁的情况）。

　　synchronized 通过与一个对象进行绑定，或者说对一个对象进行加锁，并产生一个监控对象（monitor object）。如下图所示：

  • 多线程并发执行同步代码，首先多个线程会进入集合（Entry Set），某个时间点只有一个线程可以获得(acquire) 监控对象的锁（monitor lock）, 然后执行同步代码块。
  • 如果获得锁的线程执行同步代码完毕，则会释放锁并退出同步代码区域（release and exit）。
  • 若获得锁的线程在执行同步代码时调用被锁住对象的 wait 方法，该线程则会释放（release）锁，并进入集合（Wait Set）。锁被释放后，其他位于集合（Entry Set）的线程即可争夺监控对象的锁（monitor lock）。通过调用对象的 notify 或 notifyAll 方法可以唤醒集合(Wait Set）中的线程，不同的是 notify 会唤醒集合（Wait Set）中的其中一个不确定的线程，notifyAll 会唤醒集合（Wait Set）中的所有线程。
  • 集合（Wait Set）中的线程被唤醒后，会重新进入集合（Emtry Set）与该集合中的其他线程一起争夺监控对象的锁（monitor lock），获得锁后会继续执行 wait 方法后面的代码。

【synchronized 加锁对象】

　　JVM 中使用 synchronized 进行加锁的对象有两种：分别为存储于 Java 堆的实例对象和存储于方法区的类信息对象。

　　1). synchronized 修饰实例方法，是对该方法所属的具体实例对象加锁；

　　2). synchronized 修饰静态方法，是对该方法所属的类信息对象加锁；

　　3). synchronized 同步代码块中的参数为 Class 对象或静态对象，则对 Class 对应的类信息对象加锁；

　　4). synchronized 同步代码块中的参数非 Class 对象或静态对象，而为其他实例对象，则对具体的实例对象加锁。

　　对实例对象和类信息对象加锁的区别：

  • 对实例对象进行加锁，同一时刻只有一个线程获得锁，即只有一个线程获得该实例对象的使用权，其他线程无法使用该实例对象的同步代码区域。注意：对一个实例对象进行加锁，不会影响其他实例对象中同步代码区域的执行。
  • 对类信息对象进行加锁，同一时刻只有一个线程获得锁，即只有一个线程可以调用对应类的同步代码区域（包括同步静态方法、同步实例方法、同步代码块），其他线程无法调用对应类的同步代码区域。注意：对一个类信息对象进行加锁，会影响该类所有实例对象中的同步代码区域的执行。

【synchronized 代码实践】

　　1). 多线程并发执行同一个实例对象的方法， 没有加锁的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * 多线程并发执行同一个实例对象的方法, 没有加锁的情况
 */
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 10;
        Thread[] arr = new Thread[nThreads];
        for(int n = 0; n < nThreads; n++){
            arr[n] = new Thread(c);
        }
        for(int n = 0; n < nThreads; n++){
            arr[n].start();
        }
    }
}
 
class Command implements Runnable{
     
    private int i = 0;
     
    @Override
    public void run() {
        add();
    }
     
    public void add(){
        i++;
        System.out.println(Thread.currentThread().getName() + ": " + i);
    }
}

　　从下面打印结果可以看出：在没有加锁的情况下，多线程并发执行 i++，并没有按照顺序输出，并出现了线程安全的问题。

　　

　　2). 多线程并发，对实例方法进行加锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * 多线程并发，对实例方法进行加锁
 */
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 10;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
 
class Command implements Runnable{
     
    private int i = 0;
     
    @Override
    public void run() {
        add();
    }
     
    public synchronized void add(){
        i++;
        System.out.println(Thread.currentThread().getName() + ": " + i);
    }
}

　　打印结果： 对实例方法进行加锁，即对实例对象进行加锁，多线程并发执行实例对象的方法时互斥执行，结果按顺序输出，且解决了线程安全的问题。

　　

　　3). 多线程并发执行实例对象的方法时，同步代码块锁住实例对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * 多线程并发执行实例对象的方法时，同步代码块锁住实例对象
 */
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 10;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
 
class Command implements Runnable{
     
    private int i = 0;
     
    @Override
    public void run() {
        add();
    }
     
    public void add(){
        synchronized(this){
            i++;
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

　　打印结果：可以看出同步代码块锁住实例对象的效果和对实例方法的效果一样，多线程并发执行实例对象的方法时互斥执行，结果按顺序输出，且解决了线程安全的问题。实际上这两种方法都是对实例对象进行加锁，不同的是同步方法（被加锁后的方法）互斥的内容是整个方法体，代码块互斥的内容是整个代码块，相对而言后者影响较小。使用同步代码块替代同步方法，缩小了锁粒度，也是锁优化的一种方式。

　　

　　4). 多线程并发，对实例对象加锁，其他线程是否可以调用该实例对象的非同步代码区域？是否可以调用该实例对象的同步代码区域？

　　 4.1). 设计了两个方法，一个生产方法（produce），一个消费方法（consume），对生成方法进行加锁，锁住实例对象，对消费方法不加锁，看下执行情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 5;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
 
class Command implements Runnable{
     
    @Override
    public void run() {
        produce();
        consume();
    }
     
    public synchronized void produce(){
        System.out.println(Thread.currentThread().getName() + " produce start");
        System.out.println(Thread.currentThread().getName() + " produce finish");
    }
     
    public void consume(){
        System.out.println(Thread.currentThread().getName() + " consume start");
        System.out.println(Thread.currentThread().getName() + " consume finish");
    }
}

　　打印结果：可以看出当生产方法执行的时候，消费方法也在执行。由此可见，对实例对象加锁对于调用该实例对象的非同步代码区域，是没有影响的。

　　

　　4.2). 设计了两个方法，一个生产方法（produce），一个消费方法（consume），对实例对象的生成方法和消费方法同时加锁，看下执行情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 5;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
 
class Command implements Runnable{
     
    @Override
    public void run() {
        produce();
        consume();
    }
     
    public synchronized void produce(){
        System.out.println(Thread.currentThread().getName() + " produce start");
        System.out.println(Thread.currentThread().getName() + " produce finish");
    }
     
    public synchronized void consume(){
        System.out.println(Thread.currentThread().getName() + " consume start");
        System.out.println(Thread.currentThread().getName() + " consume finish");
    }
}

　　打印结果：可以看出生产方法和消费方法互斥执行。由此可见，对实例对象加锁对于调用该实例对象的同步代码区域，是影响的。不同的线程执行同一实例对象的不同的同步方法，需要竞争同一把锁，互斥执行。

　　

　　5). 多线程并发执行静态同步方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * 多线程并发执行静态同步方法
 */
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 10;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
  
class Command implements Runnable{
      
    private int i = 0;
      
    @Override
    public void run() {
        add();
    }
      
    public synchronized void add(){
        i++;
        System.out.println(Thread.currentThread().getName() + ": " + i);
    }
}

　　打印结果：

　　

　　6). 多线程并发，同步代码块锁住类信息对象　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * 多线程并发执行静态同步方法
 */
public class Main{
    public static void main(String[] args){
        Command c = new Command();
        int nThreads = 10;
        for(int n = 0; n < nThreads; n++){
            new Thread(c).start();
        }
    }
}
  
class Command implements Runnable{
      
    private int i = 0;
      
    @Override
    public void run() {
        add();
    }
      
    public void add(){
        synchronized(Command.class){
            i++;
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

　　打印结果：

　　

　　7). 多线程并发，对类信息对象加锁，是否可以调用不同实例对象的同步代码区域？

　　7.1)  多线程并发执行不同实例对象的同步方法，不对类信息对象加锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Main{
    public static void main(String[] args){
        int nThreads = 5;
        for(int n = 0; n < nThreads; n++){
            new Thread(new Command()).start();
        }
    }
}
  
class Command implements Runnable{
     
    @Override
    public void run() {
        produce();
        consume();
    }
     
    public synchronized void produce(){
        System.out.println(Thread.currentThread().getName() + " produce start");
        System.out.println(Thread.currentThread().getName() + " produce finish");
    }
     
    public synchronized void consume(){
        System.out.println(Thread.currentThread().getName() + " consume start");
        System.out.println(Thread.currentThread().getName() + " consume finish");
    }
}

　　打印结果：可以看出不同实例对象并发执行同步代码块，不会互斥执行。

　　

　　7.2)  多线程并发执行不同实例对象的同步方法，对类信息对象加锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Main{
    public static void main(String[] args){
        int nThreads = 5;
        for(int n = 0; n < nThreads; n++){
            new Thread(new Command()).start();
        }
    }
}
  
class Command implements Runnable{
     
    @Override
    public void run() {
        produce();
        consume();
    }
     
    public void produce(){
        synchronized(Command.class){
            System.out.println(Thread.currentThread().getName() + " produce start");
            System.out.println(Thread.currentThread().getName() + " produce finish");
        }
    }
     
    public synchronized void consume(){
        System.out.println(Thread.currentThread().getName() + " consume start");
        System.out.println(Thread.currentThread().getName() + " consume finish");
    }
}

　　打印结果：在生产方法（produce）对类信息对象进行加锁，可以看到生成方法（produce）执行时与消费方法（consume）是互斥的。

　　

　　

[转帖]B4. Concurrent JVM 锁机制（synchronized）的更多相关文章

  1. B4. Concurrent JVM 锁机制（synchronized）

    [概述] JVM 通过 synchronized 关键字提供锁,用于在线程同步中保证线程安全. [synchronized 实现原理] synchronized 可以用于代码块或者方法中,产生同步代码 ...

  2. [转载]深入JVM锁机制-synchronized

    转自:http://blog.csdn.net/chen77716/article/details/6618779,并加上少量自己的理解 目前在Java中存在两种锁机制:synchronized和Lo ...

  3. 转：synchronized和LOCK的实现原理---深入JVM锁机制

    JVM底层又是如何实现synchronized的? 目前在Java中存在两种锁机制:synchronized和Lock,Lock接口及其实现类是JDK5增加的内容,其作者是大名鼎鼎的并发专家Doug ...

  4. java多线程之：深入JVM锁机制2-Lock （转载）

    前文(深入JVM锁机制-synchronized)分析了JVM中的synchronized实现,本文继续分析JVM中的另一种锁Lock的实现.与synchronized不同的是,Lock完全用Java ...

  5. 深入JVM锁机制2-Lock

    前文(深入JVM锁机制-synchronized)分析了JVM中的synchronized实现,本文继续分析JVM中的另一种锁Lock的实现.与synchronized不同的是,Lock完全用Java ...

  6. 【转载】Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference

    参考文章: http://blog.csdn.net/chen77716/article/details/6618779 目前在Java中存在两种锁机制:synchronized和Lock,Lock接 ...

  7. java 锁机制(synchronized 与 Lock)

    在java中,解决同步问题,很多时候都会使用到synchronized和Lock,这两者都是在多线程并发时候常使用的锁机制. synchronized是java中的一个关键字,也就是说是java内置的 ...

  8. 深入JVM锁机制1-synchronized

    目前在Java中存在两种锁机制:synchronized和Lock,Lock接口及其实现类是JDK5增加的内容,其作者是大名鼎鼎的并发专家Doug Lea.本文并不比较synchronized与Loc ...

  9. Java 锁机制 synchronized

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/75126630 本文出自[赵彦军的博客] 1.前言 在多线程并发编程中Synchro ...

随机推荐

  1. 【JZOJ】2126. 最大约数和

    题目大意 选取和不超过S的若干个不同的正整数,使得所有数的约数(不含它本身)之和最大. 分析 把我们分解出来的因数进行合并,存在一个不知名的数组里,然后我们大可开始我们的迪屁!!(bag),我们可以 ...

  2. 【开发笔记】- 输出String字符串使其文本对齐

    需求 一段文本做每64个字节换行处理,并添加对应的头尾注释 代码实现 public static String certFormat(String code, String beginTitle, S ...

  3. 将canvas中左上角的原点坐标位置改为左下角

    在使用canvas的时候,原点坐标在左上角,这个很犯人,因为一般的坐标基本都是在左下角,即笛卡尔坐标系,那怎么进行转变呢,在这里用到了canvas的translate,rotate,和scale进行转 ...

  4. spring mybatis错误问题该怎么解决

    1.org.apache.ibatis.exceptions.PersistenceExc org.apache.ibatis.exceptions.PersistenceException: ### ...

  5. The Preliminary Contest for ICPC Asia Shenyang 2019 F. Honk's pool

    题目链接:https://nanti.jisuanke.com/t/41406 思路:如果k的天数足够大,那么所有水池一定会趋于两种情况: ① 所有水池都是一样的水位,即平均水位 ② 最高水位的水池和 ...

  6. guava布隆过滤器

    pom引入依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava&l ...

  7. dapi 基于Django的轻量级测试平台二 前端页面

    QQ群: GitHub:https://github.com/yjlch1016/dapi 一.登录页login.html: 二.首页home.html: 三.产品线列表页product.html: ...

  8. chromedriver对应chrome版本

    chromedriver版本 支持的Chrome版本 v2.41 v67-69 v2.40 v66-68 v2.39 v66-68 v2.38 v65-67 v2.37 v64-66 v2.36 v6 ...

  9. ORM基本增删改查

    将上一节建造好的数据库 引入Navicate copy_path找到数据表路径 再用navicat打开 创建好的db不只一张表,其中第一张是我们创建的可以用的表  ,其他都是django自带功能所需表 ...

  10. 出现 sudo: unable to resolve host XXX 信息解决办法

    Ubuntu环境,  每次执行sudo 就出现这个警告讯息:sudo: unable to resolve host XXX虽然sudo 还是可以正常执行,是机器在反解上的问题, 所以就直接从/etc ...