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. 类似hover的css伪类注解

    a:link { font-size: 14pt; text-decoration: underline; color: blue; } /*设置a对象在未被访问前的样式表属性 .*/ a:hover ...

  2. 【案例】电子生产中的排程问题如何解决？APS助力智能化排产

    共进电子是典型的消费类电子制造企业,以ODM业务为主,立足双O(OEM/ODM),发展自主品牌.其中,生产模式特点包括: 批量制造.多品种小批量.面向订单生产: 产品结构复杂,设计变更频繁:生产计划复 ...

  3. OEL7.6设置光盘YUM源

    先把原来的yum源改名让他失效 mv public-yum-ol7.repo public-yum-ol7.repo.bak 然后新建个yum源 [root@localhost yum.repos.d ...

  4. angular6 监听url查询参数变化刷新页面

    快照snapshot取到的参数是组件第一次渲染时候的参数,当我们在页面中需要根据不同的url查询参数显示不同的内容时,快照就不能满足我们的需要了,这时候就要用ActivatedRoute服务的quer ...

  5. 一文搞定PGA_LGA_BGA

    概述 什么是LGA.PGA.BGA类型的封装?众所周知,CPU封装的类型主要为三种:LGA,PGA,BGA,其中LGA封装是最常见的,intel处理器都是采用这种类型的封装,而PGA封装则是AMD常用 ...

  6. rhel7 学习第二天

    参加<Linux就该这么学>在线培训的第二天,学习了虚拟环环境的搭建和红帽7的安装,同时也学习了rhel7的基本命令格式,以及systemctl的使用.

  7. matplotlib 绘制正余弦曲线图

    1.普通风格 代码 import numpy as npimport matplotlib.pyplot as plt x = np.linspace(0, 2*np.pi, 50)y1 = np.s ...

  8. D. Maxim and Array

    https://www.cnblogs.com/qscqesze/p/5925893.html  原博客 http://codeforces.com/group/1EzrFFyOc0/contest/ ...

  9. centos 7.3 安装 mysqldb 报错 EnvironmentError: mysql_config not found ERROR: Command errored out with exit status 1: python setup.py egg_info Check the logs for full command output.

    ERROR: Command errored : command: /usr/bin/python -c 'import sys, setuptools, tokenize; sys.argv[0] ...

  10. scannet数据集

    数据集包含xyz和label信息,不包含颜色信息. 一共1513个室内场景数据(每个场景中点云数量都不一样),共21个类别的对象(0-20,总共已知类别应该是20,类别0应该是未知类别,即未标注点云) ...