synchronized 关键字解析

同步锁依赖于对象，每个对象都有一个同步锁。

现有一成员变量 Test，当线程 A 调用 Test 的 synchronized 方法，线程 A 获得 Test 的同步锁，同时，线程 B 也去调用 Test 的 synchronized 方法，此时线程 B 无法获得 Test 的同步锁，必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码。

综上，正确使用 synchronized 关键字可确保原子性。

synchronized 关键字的特性应用

特性 1：

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的synchronized 方法 或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。

DEMO1，synchronized 方法：

public class Test {

    private static class Counter {

        public synchronized void count() {

            for (int i = 0; i < 6; i++) {

                System.out.println(Thread.currentThread().getName() + "， i = " + i);

            }

        }

    }

    private static class MyThread extends Thread {

        private Counter mCounter;

        public MyThread(Counter counter) {

            mCounter = counter;

        }

        @Override

        public void run() {

            super.run();

            mCounter.count();

        }

    }

    public static void main(String[] var0) {

        Counter counter = new Counter();

        // 注：myThread1 和 myThread2 是调用同一个对象 counter

        MyThread myThread1 = new MyThread(counter);

        MyThread myThread2 = new MyThread(counter);

        myThread1.start();

        myThread2.start();

    }

}

DEMO1 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

Thread-1， i = 0

Thread-1， i = 1

Thread-1， i = 2

Thread-1， i = 3

Thread-1， i = 4

Thread-1， i = 5

DEMO2，synchronized 代码块：

public class Test {

    private static class Counter {

        public void count() {

            synchronized (this) {

                for (int i = 0; i < 6; i++) {

                    System.out.println(Thread.currentThread().getName() + "， i = " + i);

                }

            }

        }

    }

    private static class MyThread extends Thread {

        private Counter mCounter;

        public MyThread(Counter counter) {

            mCounter = counter;

        }

        @Override

        public void run() {

            super.run();

            mCounter.count();

        }

    }

    public static void main(String[] var0) {

        Counter counter = new Counter();

        MyThread myThread1 = new MyThread(counter);

        MyThread myThread2 = new MyThread(counter);

        myThread1.start();

        myThread2.start();

    }

}

DEMO2 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

Thread-1， i = 0

Thread-1， i = 1

Thread-1， i = 2

Thread-1， i = 3

Thread-1， i = 4

Thread-1， i = 5

可见，当同步锁未释放时，其他线程将被阻塞，直至获得同步锁。

而且 DEMO1 和 DEMO2 的输出结果是一样的，synchronized 方法 和 synchronized 代码块的不同之处在于 synchronized 方法 作用域较大，作用于整个方法，而 synchronized 代码块 可控制具体的作用域，更精准控制提高效率。（毕竟阻塞的都是时间啊）

DEMO3，仅修改 main 方法：

    public static void main(String[] var0) {

        // 注意：myThread1 和 myThread2 传入的 Counter 是两个不同的对象

        MyThread myThread1 = new MyThread(new Counter());

        MyThread myThread2 = new MyThread(new Counter());

        myThread1.start();

        myThread2.start();

    }

DEMO3 输出：

Thread-0， i = 0

Thread-1， i = 0

Thread-0， i = 1

Thread-1， i = 1

Thread-1， i = 2

Thread-1， i = 3

Thread-0， i = 2

Thread-1， i = 4

Thread-0， i = 3

Thread-1， i = 5

Thread-0， i = 4

Thread-0， i = 5

同步锁基于对象，只要锁的来源一致，即可达到同步的作用。所以，但对象不一样，则不能达到同步效果。

特性 2：

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的其他synchronized 方法 或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。（注意：重点是其他）

DEMO4，仅修改 doOtherThings 方法的修饰：

public class Test {

    private static class Counter {

        public synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }

        public synchronized void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

    }

    public static void main(String[] var0) {

        final Counter counter = new Counter();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO4 输出：

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

可见，synchronized 获得的同步锁并非仅仅锁住代码，而是锁住整个对象。

此时应提及 happens-before 原则，正因 happens-before 原则的存在才有此现象的发生。
happens-before 原则的其中一条：

管理锁定原则：一个 unLock 操作先行发生于后面对同一个锁的 lock 操作。
（此处暂不作过多解释，解释起来能再写一篇文章了）

DEMO5，仅修改 doOtherThings 方法：

        public void doOtherThings(){

            synchronized (this){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

DEMO5 输出：

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

DEMO4 和 DEMO5 的输出结果竟然一致！没错，因为他们的同步锁来源一致（都是本实例自己），所以可以达到同步效果。

// 这两个 synchronized 锁的是同一个对象

public synchronized void count(){};

public void doOtherThings(){

       synchronized (this){}

}

DEMO6，去掉 doOtherThings 方法的同步关键字：

public void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

DEMO6 输出：

Thread-0 sleep

Thread-1 doOtherThings

Thread-0 awake

当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，无论同步锁是否释放，其他线程调用同一对象的其他 非 synchronized 方法 或者 非 synchronized 代码块时可立即调用。

实例锁和全局锁

以上 DEMO 实现的都是实例锁。锁住（作用域）的是具体某一对象实例。

什么是全局锁？

锁住整个 Class，而非某个对象或实例。

注：单例型的实例锁不属于全局锁。

全局锁的实现：

静态 synchronized 方法

DEMO7：

public class Test {

    private static class Counter {

        public static synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }

        public static synchronized void doOtherThings(){

            System.out.println(Thread.currentThread().getName() + " doOtherThings");

        }

    }

    public static void main(String[] var0) {

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.doOtherThings();

            }

        }).start();

    }

}

DEMO7 输出：

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

static 声明的方法为全局方法，与对象实例化无关，所以 static synchronized 方法为全局同步方法，与对象实例化无关。

synchronized 具体 Class 的代码块

DEMO8：

public class Test {

    private static class Counter {

        public static synchronized void count() {

            System.out.println(Thread.currentThread().getName() + " sleep");

            try {

                Thread.sleep(3000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + " awake");

        }

        public void doOtherThings(){

            synchronized (Counter.class){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

    }

    public static void main(String[] var0) {

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                Counter counter = new Counter();

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO8 输出：

Thread-0 sleep

Thread-0 awake

Thread-1 doOtherThings

synchronized (Counter.class) 获得的同步锁是全局的，static synchronized 获得的同步锁也是全局的，同一个锁，所以达到同步效果。

区分 synchronized (this) 与 synchronized (Class.class)

DEMO9：

public class Test {

    private static class Counter {

        public void count() {

            synchronized (this){

                System.out.println(Thread.currentThread().getName() + " sleep");

                try {

                    Thread.sleep(3000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(Thread.currentThread().getName() + " awake");

            }

        }

        public void doOtherThings(){

            synchronized (Counter.class){

                System.out.println(Thread.currentThread().getName() + " doOtherThings");

            }

        }

    }

    public static void main(String[] var0) {

        final Counter counter = new Counter();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.count();

            }

        }).start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                counter.doOtherThings();

            }

        }).start();

    }

}

DEMO9 输出：

Thread-0 sleep

Thread-1 doOtherThings

Thread-0 awake

synchronized (this) 获得的是具体对象实例 counter 的锁，而 synchronized (Counter.class) 获得的是全局锁，两把不同的锁，所以不能达到同步效果。

============= End

synchronized 关键字解析的更多相关文章

  1. Java线程和多线程（十四）——Synchronized关键字解析

    曾经有一个比较有趣的面试问题,那就是,关于使用synchronized关键字,是用在方法上面尾号,还是用在一个代码块上面为好? 答案就是使用锁定代码块为更好.因为这样不会锁定对象.当synchroni ...

  2. Java 多线程并发编程之 Synchronized 关键字

    synchronized 关键字解析 同步锁依赖于对象,每个对象都有一个同步锁. 现有一成员变量 Test,当线程 A 调用 Test 的 synchronized 方法,线程 A 获得 Test 的 ...

  3. Java并发之synchronized关键字深度解析（二）

    前言 本文继续[Java并发之synchronized关键字深度解析(一)]一文而来,着重介绍synchronized几种锁的特性. 一.对象头结构及锁状态标识 synchronized关键字是如何实 ...

  4. Java对象锁和类锁全面解析（多线程synchronized关键字）

    最近工作有用到一些多线程的东西,之前吧,有用到synchronized同步块,不过是别人怎么用就跟着用,并没有搞清楚锁的概念.最近也是遇到一些问题,不搞清楚锁的概念,很容易碰壁,甚至有些时候自己连用没 ...

  5. Java并发之synchronized关键字深度解析（三）

    前言 本篇主要介绍一下synchronized的批量重偏向和批量撤销机制,属于深水区,大家提前备好氧气瓶. 上一篇说完synchronized锁的膨胀过程,下面我们再延伸一下synchronized锁 ...

  6. java线程同步以及对象锁和类锁解析（多线程synchronized关键字）

    一.关于线程安全 1.是什么决定的线程安全问题? 线程安全问题基本是由全局变量及静态变量引起的. 若每个线程中对全局变量.静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的:若有多个线 ...

  7. Java并发编程：volatile关键字解析

    Java并发编程:volatile关键字解析 volatile这个关键字可能很多朋友都听说过,或许也都用过.在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果.在 ...

  8. （转）Java并发编程：volatile关键字解析

    转:http://www.cnblogs.com/dolphin0520/p/3920373.html Java并发编程:volatile关键字解析 volatile这个关键字可能很多朋友都听说过,或 ...

  9. Java 多线程 —— synchronized关键字

    java 多线程 目录: Java 多线程——基础知识 Java 多线程 —— synchronized关键字 java 多线程——一个定时调度的例子 java 多线程——quartz 定时调度的例子 ...

随机推荐

  1. 数学基础IV 欧拉函数 Miller Rabin Pollard's rho 欧拉定理 行列式

    找了一些曾经没提到的算法.这应该是数学基础系最后一篇. 曾经的文章: 数学基础I 莫比乌斯反演I 莫比乌斯反演II 数学基础II 生成函数 数学基础III 博弈论 容斥原理(hidden) 线性基(h ...

  2. Python-类与对象

    类与对象的概念 类即类别.种类,是面向对象设计最重要的概念,从一小节我们得知对象是特征与技能的结合体,而类则是一系列对象相似的特征与技能的结合体. 那么问题来了,先有的一个个具体存在的对象(比如一个具 ...

  3. 网络七层模型及TCP、UDP，一次HTTP请求都发生了什么

    一.七层网络模型 http协议运行在应用层   二.TCP-UDP TCP.UDP协议的区别 一次Http 请求,这个过程都发生了什么 TCP 协议如何保证可靠传输 HTTP和HTTPS的区别 TCP ...

  4. Navicat 或者Java的JDBC通过SSH Tunnel连接MySQL数据库

    JDBC通过SSH Tunnel连接MySQL数据库 - 明明 - CSDN博客https://blog.csdn.net/a351945755/article/details/21782693 Na ...

  5. JEECG 3.7 Memory Leak

    JEECG 3.7 版本常见问题贴 - JEECG官方网站-企业级JAVA快速开发平台 - Powered by Discuz!http://www.jeecg.org/forum.php?mod=v ...

  6. Spring.profile配合Jenkins发布War包，实现开发、测试和生产环境的按需切换

    前两篇不错 Spring.profile实现开发.测试和生产环境的配置和切换 - Strugglion - 博客园https://www.cnblogs.com/strugglion/p/709102 ...

  7. PHP之CLI模式

    转载: http://www.cnblogs.com/zcy_soft/archive/2011/12/10/2283437.html 所有的PHP发行版,不论是编译自源代码的版本还是预创建的版本,都 ...

  8. 【Python3练习题 013】 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字

    a=input('输入数字>>>') count=int(input('几个数字相加>>>')) ret=[] for i in range(1,count+1): ...

  9. # 【Python3练习题 007】 有一对兔子，从出生后第3个月起每个月都生一对兔子， # 小兔子长到第三个月后每个月又生一对兔子， # 假如兔子都不死，问每个月的兔子总数为多少？

    # 有一对兔子,从出生后第3个月起每个月都生一对兔子,# 小兔子长到第三个月后每个月又生一对兔子, # 假如兔子都不死,问每个月的兔子总数为多少?这题反正我自己是算不出来.网上说是经典的“斐波纳契数列 ...

  10. Baby-Step-Giant-Step 很酷的算法

    Baby-Step-Giant-Step BSGS算法用于解决形如:      A  ^  x  ≡  B  (  mod  C  ) 的问题.  学这个算法前需要具备以下知识:快速幂取模.扩展欧几里 ...