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),作者:Gang.Wang

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

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

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

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java Web学习总结(六)——Servlet开发(二)

      在Servlet的配置文件web.xml中,可以使用一个或多个<init-param>标签为servlet配置一些初始化参数。

    Java团长
  • Java Web学习总结(七)——HttpServletResponse对象(一)

    Web服务器收到客户端的http请求,会针对每一次请求,分别创建一个用于代表请求的request对象、和代表响应的response对象。request和resp...

    Java团长
  • JAVA之旅(一)——基本常识,JAVA概念,开发工具,关键字/标识符,变量/常量,进制/进制转换,运算符,三元运算

    比如6:6/2 = 3 余 0 3 / 2 = 1 余 1 那就是从个位数开始011,读起来就是110了

    Java团长
  • wepy踩坑-npm ERR! cb() never called!

    在安装微信小程序框架wepy - 滑动删除插件 https://github.com/GeoffZhu/wepy-swipe-delete的时候报错。

    王小婷
  • Hexo优化 --- 利用 Markdown 语法画流程图

    一份执着✘
  • 洛谷 P1896 [SCOI2005]互不侵犯(状压dp)

    在N×N的棋盘里面放K个国王,使他们互不攻击,共有多少种摆放方案。国王能攻击到它上下左右,以及左上左下右上右下八个方向上附近的各一个格子,共8个格子。

    glm233
  • 模块类和自动化用例实践--视频演示

    讲完了基类的时间接下来就是模块类。本期分享内容是以我们某个项目的usercenter模块类内容,包含了用户Users管理类和自动化测试用例的编写等等。关于自动化...

    FunTester
  • Nodejs跨平台环境变量设置cross-env

    在搭建公司新的前端工程的架构中,需要在在package.json的scripts标签下配置一系列命令,如下所示:

    javascript.shop
  • LoadClass和forName的区别

    装载:通过累的全限定名获取二进制字节流,将二进制字节流转换成方法区中的运行时数据结构,在内存中生成Java.lang.class对象;

    葆宁
  • 钉钉忙着撕微信,云之家却在密谋?

    人称T客

扫码关注云+社区

领取腾讯云代金券