Synchronized 理解

用法：1.同步方法。2.同步静态方法。3同步代码块。

理解Synchronized 的关键是“锁” （原理在最后）

同步代码有“锁”者执行。所谓的锁必须是同一个。静态的方法是该类的.class ，而非静态的或代码块指的是同一个对象。

来说说不同情况下的锁的情形。

一：类中有普通同步方法 

package test;public class Test {public synchronized void fun() {System.out.println("fun start");try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}public static void main(String[] args) {Test test = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t2.start();}}

显然是同步执行的。就是t线程执行结束，t1才能进度，没有什么异议。

现在做一个改变

 1 package test;
 2
 3 public class Test {
 4     public synchronized void fun() {
 5         System.out.println("fun start");
 6         try {
 7             Thread.sleep(1000);
 8         } catch (InterruptedException e) {
 9             e.printStackTrace();
10         }
11         System.out.println("fun end");
12     }
13
14     public synchronized void funNoSyc() {
15         System.out.println("funNoSyc start");
16         try {
17             Thread.sleep(1000);
18         } catch (InterruptedException e) {
19             e.printStackTrace();
20         }
21         System.out.println("funNoSyc end");
22     }
23
24     public static void main(String[] args) {
25
26         Test test = new Test();
27         Test test1 = new Test();
28         Thread t = new Thread(new Runnable() {
29
30             @Override
31             public void run() {
32                 test.fun();
33             }
34         });
35         t.start();
36         Thread t2 = new Thread(new Runnable() {
37
38             @Override
39             public void run() {
40                 test1.fun();
41             }
42         });
43         t2.start();
44
45     }
46
47 }

View Code

Test new了两个不同对象，看一下执行结果。

可以看到同时执行的，根本没有同步。原是，两个对象，不是同一把“锁” ，很好理解吧。

结论：方法的同步对使用了同一同步类（同一锁）的操作起作用。

接下来再变一下，如果类同有多个同步方法，调用过程会是啥样？

两个同步方法，1和2。使用同一个对象"test".线程1调用fun 线程2调fun1 .看结果。代码下。

package test;public class Test {public synchronized void fun() {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}public synchronized void fun1() {System.out.println("fun1 start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun1 end");}public static void main(String[] args) {Test test = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {test.fun1();}});t2.start();}}

运行结果

结果可以看出，运行fun的时候，fun1不能运行，只能等待。

结论：方法上加 synchronized 隐式加了synchronize(this).所以同一个类中，不同的同步方法使用的是同一个锁，只要一个同步方法在执行，其它方法只能等待。

二：类中同步的静态方法

看代码

package test;public class Test {public static synchronized void fun() {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}public static void main(String[] args) {Test test = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {Test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {Test.fun();}});t2.start();}}

运行结果 是同步的。先后执行。

改一下，用不同的对象去执行：

最后结果一样的。

如果类中有多个静态方法

package test;public class Test {public static synchronized void fun() {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}public static synchronized void fun1() {System.out.println("fun1 start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun1 end");}public static void main(String[] args) {Test test = new Test();Test test1 = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {test1.fun1();}});t2.start();}}

执行结果：

一个静态方法在执行，另一个则等待。

结论：所有静态法都使用的同一个锁，就是该类的.class。所以所有静态方法都是互斥的。开发上要好好考虑，会有性能问题。

这就所谓的类锁，其实就是所有静态方法使用的同一个锁。

三：同步代码块

synchronized （锁）｛　　代码｝

到这儿其实都不用试了，这里面的代码同步关键还是这个锁。同锁（同一对象）互斥。

package test;public class Test {public void fun() {synchronized (this) {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}}public static void main(String[] args) {Test test = new Test();// Test test1 = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {//同一对象共互斥
                test.fun();// test1.fun();
            }});t2.start();}}

结果：

fun start
fun end
fun start
fun end

不同对象，不起作用。看下面代码结果

package test;public class Test {public void fun() {synchronized (this) {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}}public static void main(String[] args) {Test test = new Test();Test test1 = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun();}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {// 同一对象共互斥// test.fun();
                test1.fun();}});t2.start();}}

结果：

fun start
fun start
fun end
fun end

或者修改代码如下：

传入一个对象锁

package test;public class Test {public void fun(Object object) {synchronized (object) {System.out.println("fun start");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("fun end");}}public static void main(String[] args) {Test test = new Test();Test test1 = new Test();Thread t = new Thread(new Runnable() {@Overridepublic void run() {test.fun(test);}});t.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {test1.fun(test);}});t2.start();}}

这样的代码块是在不同的对象，但是传的是同一个对象锁，结果照样还是同步的。

总结：synchronized 工作的关键就是这个对象锁。静态的方法所用锁就是类.class，所有人共用，因为只有一个，非静态的就是具体的对象。

同步只对使用的同一个锁的过程起作用。

Synchronized 原理

　　如果对上面的执行结果还有疑问，也先不用急，我们先来了解Synchronized的原理，再回头上面的问题就一目了然了。我们先通过反编译下面的代码来看看Synchronized是如何实现对代码块进行同步的：

1 package com.paddx.test.concurrent;
2
3 public class SynchronizedDemo {
4     public void method() {
5         synchronized (this) {
6             System.out.println("Method 1 start");
7         }
8     }
9 }

反编译结果：

关于这两条指令的作用，我们直接参考JVM规范中描述：

monitorenter ：

Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:
• If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.
• If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.
• If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership.

这段话的大概意思为：

每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

monitorexit：　

The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.
The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

这段话的大概意思为：

执行monitorexit的线程必须是objectref所对应的monitor的所有者。

指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

　　通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

　　我们再来看一下同步方法的反编译结果：

源代码：

1 package com.paddx.test.concurrent;
2
3 public class SynchronizedMethod {
4     public synchronized void method() {
5         System.out.println("Hello World!");
6     }
7 }

反编译结果：

　　从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成（理论上其实也可以通过这两条指令来实现），不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成

转载于:https://www.cnblogs.com/mamamia/p/8005922.html

线程同步synchronized理解相关推荐

  1. Java线程(二)：线程同步synchronized和volatile

    上篇通 过一个简单的例子说明了线程安全与不安全,在例子中不安全的情况下输出的结果恰好是逐个递增的(其实是巧合,多运行几次,会产生不同的输出结果),为什么 会产生这样的结果呢,因为建立的Count对象是 ...

  2. java多线程：线程同步synchronized（不同步的问题、队列与锁），死锁的产生和解决

    0.不同步的问题 并发的线程不安全问题: 多个线程同时操作同一个对象,如果控制不好,就会产生问题,叫做线程不安全. 我们来看三个比较经典的案例来说明线程不安全的问题. 0.1 订票问题 例如前面说过的 ...

  3. Java 线程同步 synchronized

    先来看一个不带线程同步的例子,这个例子很简单,只是让两个线程输出同样的内容,并不做其他的事,所以,线程同步在这里体现的并不明显. import java.util.Date;public class ...

  4. 线程同步synchronized

    转载请标明出处: http://blog.csdn.net/hai_qing_xu_kong/article/details/70670024 本文出自:[顾林海的博客] 前言 在编写多线程应用时,读 ...

  5. 【Java线程】线程同步—synchronized Lock

    同步的实现当然是采用锁了,java中使用锁的两个基本工具是 synchronized 和 Lock. ========================================== synchr ...

  6. java线程同步(synchronized,wait,notify,notifyAll)

    synchronized: 包括synchronized方法和synchronized块. synchronized方法使用this作为默认的"同步监视器",而synchroniz ...

  7. 线程同步初解---转载

    //线程安全问题的原因其实就是:线程执行多条语句的时候出现了阻塞,然后没有执行完该线程另一线程就启动了. //解决方法就是同步代码块:synchronized(对象) //synchronized(对 ...

  8. java线程同步——条件对象+synchronized 关键字

    [0]README 0.1) 本文描述转自 core java volume 1, 源代码为原创,旨在理解 java线程同步--条件对象+synchronized 关键字 的相关知识: 0.2)for ...

  9. JAVA并发编程3_线程同步之synchronized关键字

    在上一篇博客里讲解了JAVA的线程的内存模型,见:JAVA并发编程2_线程安全&内存模型,接着上一篇提到的问题解决多线程共享资源的情况下的线程安全问题. 不安全线程分析 public clas ...

最新文章

  1. runLoop和runtime的分析
  2. jsp上传文件名乱码
  3. LIBSVM 多分类问题- 葡萄酒种类识别
  4. easyui点击搜索的时候获取不要文本框里面的值的问题
  5. 室内空气流动原理图_新风系统原理图—新风系统原理介绍
  6. 在Windows Vista中使用符号链接
  7. win7 计算器 android,教你巧妙应用Win7计算器和时钟
  8. python银行系统模拟演练_python多线程实现代码(模拟银行服务操作流程)
  9. Linux内存管理：内存描述之内存区域zone
  10. java根据所给的根目录获取底下所有文件夹结构
  11. Android中的Intent详细讲解【转】
  12. find命令结合exec和xargs使用的区别
  13. 计算机专业有必要考软考吗,软考初级程序员有用吗_有必要考吗_上学吧
  14. 机器学习中的数学——激活函数（一）：Sigmoid函数
  15. Jquery 例外被抛出且未被接住
  16. 新手gxf学python---文件操作之登录、注册功能
  17. js中的引号使用不正确导致js方法传入参数类型错误
  18. POI异常：java.lang.NoClassDefFoundError: org.openxmlformats.schemas.spreadsheetml.x2
  19. 修改PPT输出JPG图片分辨率为300 dpi
  20. 【CSDN竞赛第5期】编程竞赛总结

热门文章

  1. eclipse:解决修改文件需要重启tomcat问题
  2. vue实例、指令、生命周期
  3. ssm整合2 增删改
  4. 阅读“CodeIgniter中国》文档首页》常规主题》安全”之抄录
  5. Transformer详细解读与预测实例记录
  6. R语言进阶 | 变量赋值背后的机制与R语言内存优化
  7. 《剑指offer》数字在排序数组中出现的次数
  8. 《数据库SQL实战》查找入职员工时间排名倒数第三的员工的所有信息
  9. 使用C语言读取properties文件V1.0
  10. Markdown中数学公式整理