java synchronized详解

记下来,很重要。

Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

举例说明: 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

package ths;
public class Thread1 implements Runnable {       public void run() {            synchronized(this) {                 for (int i = 0; i < 5; i++) {                      System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);                 }            }       }       public static void main(String[] args) {            Thread1 t1 = new Thread1();            Thread ta = new Thread(t1, "A");            Thread tb = new Thread(t1, "B");            ta.start();            tb.start();       } }

结果:

     A synchronized loop 0       A synchronized loop 1       A synchronized loop 2       A synchronized loop 3       A synchronized loop 4       B synchronized loop 0       B synchronized loop 1       B synchronized loop 2       B synchronized loop 3       B synchronized loop 4

二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

package ths;
public class Thread2 {       public void m4t1() {            synchronized(this) {                 int i = 5;                 while( i-- > 0) {                      System.out.println(Thread.currentThread().getName() + " : " + i);                      try {                           Thread.sleep(500);                      } catch (InterruptedException ie) {                      }                 }            }       }       public void m4t2() {            int i = 5;            while( i-- > 0) {                 System.out.println(Thread.currentThread().getName() + " : " + i);                 try {                      Thread.sleep(500);                 } catch (InterruptedException ie) {                 }            }       }       public static void main(String[] args) {            final Thread2 myt2 = new Thread2();            Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );            Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );            t1.start();            t2.start();       } }

结果:

     t1 : 4       t2 : 4       t1 : 3       t2 : 3       t1 : 2       t2 : 2       t1 : 1       t2 : 1       t1 : 0       t2 : 0

三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     //修改Thread2.m4t2()方法:       public void m4t2() {            synchronized(this) {                 int i = 5;                 while( i-- > 0) {                      System.out.println(Thread.currentThread().getName() + " : " + i);                      try {                           Thread.sleep(500);                      } catch (InterruptedException ie) {                      }                 }            }
     }

结果:

     t1 : 4       t1 : 3       t1 : 2       t1 : 1       t1 : 0       t2 : 4       t2 : 3       t2 : 2       t2 : 1       t2 : 0

四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     //修改Thread2.m4t2()方法如下:
     public synchronized void m4t2() {            int i = 5;            while( i-- > 0) {                 System.out.println(Thread.currentThread().getName() + " : " + i);                 try {                      Thread.sleep(500);                 } catch (InterruptedException ie) {                 }            }       }

结果:

     t1 : 4       t1 : 3       t1 : 2       t1 : 1       t1 : 0       t2 : 4       t2 : 3       t2 : 2       t2 : 1       t2 : 0

五、以上规则对其它对象锁同样适用:

package ths;
public class Thread3 {      class Inner {           private void m4t1() {                int i = 5;                while(i-- > 0) {                     System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);                     try {                          Thread.sleep(500);                     } catch(InterruptedException ie) {                     }                }           }           private void m4t2() {                int i = 5;                while(i-- > 0) {                     System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);                     try {                          Thread.sleep(500);                     } catch(InterruptedException ie) {                     }                }           }      }      private void m4t1(Inner inner) {           synchronized(inner) { //使用对象锁           inner.m4t1();      }      private void m4t2(Inner inner) {           inner.m4t2();      }      public static void main(String[] args) {           final Thread3 myt3 = new Thread3();           final Inner inner = myt3.new Inner();           Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");      Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2");      t1.start();      t2.start();   } }

结果:

尽管线程t1获得了对Inner的对象锁,但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

     t1 : Inner.m4t1()=4       t2 : Inner.m4t2()=4       t1 : Inner.m4t1()=3       t2 : Inner.m4t2()=3       t1 : Inner.m4t1()=2       t2 : Inner.m4t2()=2       t1 : Inner.m4t1()=1       t2 : Inner.m4t2()=1       t1 : Inner.m4t1()=0       t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized:

     private synchronized void m4t2() {            int i = 5;            while(i-- > 0) {                 System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);                 try {                      Thread.sleep(500);                 } catch(InterruptedException ie) {                 }            }       }

结果:

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁,所以t2对Inner.m4t2()的访问也被阻塞,因为m4t2()是Inner中的一个同步方法。

     t1 : Inner.m4t1()=4       t1 : Inner.m4t1()=3       t1 : Inner.m4t1()=2       t1 : Inner.m4t1()=1       t1 : Inner.m4t1()=0       t2 : Inner.m4t2()=4       t2 : Inner.m4t2()=3       t2 : Inner.m4t2()=2       t2 : Inner.m4t2()=1       t2 : Inner.m4t2()=0
  • 原文:http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html#!comments

原文发布于微信公众号 - Java团长(javatuanzhang)

原文发表时间:2018-01-11

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏自学笔记

python基本常识

tuple,str都可以看做是一种list,都可以进行切片操作。 利用切片操作,去掉一个字符串的前后空格。要注意是是前后空格是不止一个的,可能有很多个。

3515
来自专栏曾大稳的博客

c基础

981
来自专栏程序员的知识天地

最值得你收藏的30个Python常用小技巧!

[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 121, 144, 169, 196, 225,...

1322
来自专栏老付的网络博客

详解.net中IL语言

中间语言,又称(IL语言)。充当Clr与.net 平台的中间语言,比如用C#编写程序,编译器首先是把C#代码转译成IL语言,最终由Clr解释执行,下面我们学习下...

1672
来自专栏Vamei实验室

Python标准库05 存储对象 (pickle包,cPickle包)

在之前对Python对象的介绍中 (面向对象的基本概念,面向对象的进一步拓展),我提到过Python“一切皆对象”的哲学,在Python中,无论是变量还是函数,...

2069
来自专栏我是业余自学C/C++的

redis_3.0.7_sds.c_sdsempty_so_on

1053
来自专栏编程

Python入门白皮书#P01 Lists

文档: 我们以Google Python Exercises作为练习素材。 参考对应的文档 https://developers.google.com/edu/...

2026
来自专栏信安之路

利用Java反射和类加载机制绕过JSP后门检测

JSP 后门,一般是指文件名以 .jsp 等后缀结尾的,可运行于 Java servlet 及相关容器和组件内的通用 JSP 脚本。

3450
来自专栏偏前端工程师的驿站

意译:《JVM Internals》

译者语                                  为加深对JVM的了解和日后查阅时更方便,于是对原文进行翻译。内容是建立在我对JVM的认...

2477
来自专栏PHP在线

PHP开发需要了解的知识

二进制安全功能(binary-safe function)是指在一个二进制文件上所执行的不更改文件内容的功能或者操作。这能够保证文件不会因为某些操作而遭到损坏。...

2995

扫码关注云+社区

领取腾讯云代金券