synchronized简介


  Java提供了一种内置的锁机制来支持原子性:同步代码块(Synchronized Block)。同步代码块包括两部分:一个作为锁对象的引用,一个作为由这个锁保护的代码块。以关键字synchronized来修饰的方法就是一种横跨整个方法体的同步代码块,其中该同步代码块的锁就是方法调用所有的对象。静态的synchronized方法以class对象作为锁。

synchronized(this){
//访问或修改由锁保护的共享状态
}

  每个Java对象都可以用做一个实现同步的锁,这些锁称为内置锁或监视锁,Java的内置锁相当于一种互斥锁,这意味着最多只有一个线程能持有这种锁。其访问规则为:

  • 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
  • 然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
  • 尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
  • 第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
  • 以上规则对其它对象锁同样适用.

实例说明


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

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

程序执行结果为:

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

public class Test {
public void m4t1() {
synchronized(this) {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
} public void m4t2() {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
} public static void main(String[] args) {
final Test myt2 = new Test();
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();
}
}

程序执行结果为:

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

public class Test {
public void m4t1() {
synchronized(this) {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
synchronized(this) {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
} public static void main(String[] args) {
final Test myt2 = new Test();
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();
}
}

程序执行结果为:

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

public class Test { 
    public void m4t1() { 
         synchronized(this) { 
              int i = 3
              while( i-- > 0) { 
                   System.out.println(Thread.currentThread().getName() + " : " + i); 
                   try 
                       Thread.sleep(500); 
                   } catch (InterruptedException ie) { 
                   
              
         
    }
  
    public synchronized void m4t2() { 
        int i = 3
        while( i-- > 0) { 
             System.out.println(Thread.currentThread().getName() + " : " + i); 
             try 
                  Thread.sleep(500); 
             } catch (InterruptedException ie) { 
             
        
   }
 
    public static void main(String[] args) { 
         final Test myt2 = new Test(); 
         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(); 
    }
}

程序执行结果为:

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

public class Test {
class Inner {
private void m4t1() {
int i = 3;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
} private void m4t2() {
int i = 3;
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 Test myt3 = new Test();
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中的非同步部分。所以两个线程互不干扰。

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

private synchronized void m4t2() {
int i = 3;
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中的一个同步方法。

synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。

1. synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:

  public synchronized void accessVal(int newVal);  

  synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行,否则所属线程阻塞,方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized)。

  在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成员变量的访问。

  synchronized 方法的缺陷:若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供了更好的解决办法,那就是 synchronized 块。

2. synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:

synchronized(syncObject) {
//允许访问控制的代码
}

  synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行,具体机制同前所述。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。

  总的说来,synchronized关键字可以作为函数的修饰符,也可作为函数内的语句,也就是平时说的同步方法和同步语句块。如果再细的分类,synchronized可作用于instance变量、object reference(对象引用)、static函数和class literals(类名称字面常量)身上。

  在进一步阐述之前,我们需要明确几点:

  A.无论synchronized关键字加在方法上还是对象上,它取得的锁都是对象,而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

  B.每个对象只有一个锁(lock)与之相关联。

  C.实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

  D.  一般的同步方法与synchronized (this)效果一样,都是锁定调用这个同步方法对象(该类的一个具体实例)

   E.  静态同步方法与synchronized (Class.this)效果一样,锁定的是当前调用这个方法的对象所属的类(Class,而不再是由这个Class产生的某个具体对象了)。

  F.  如果同时定义一般的同步方法和静态同步方法,那么这个类的同一对象Obj。在多线程中分别访问A和B两个方法时,不会构成同步,因为它们的锁都不一样。A方法的锁是Obj这个对象

  接着来讨论synchronized用到不同地方对代码产生的影响:

  假设P1、P2是同一个类的不同对象,这个类中定义了以下几种情况的同步块或同步方法,P1、P2就都可以调用它们。

  1. 把synchronized当作函数修饰符时,示例代码如下:

public synchronized void methodAAA(){
//….
}

  这也就是同步方法,那这时synchronized锁定的是哪个对象呢?它锁定的是调用这个同步方法对象。也就是说,当一个对象P1在不同的线程中执行这个同步方法时,它们之间会形成互斥,达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。上边的示例代码等同于如下代码:

public void methodAAA(){
   synchronized (this){ // (1)//…..
  }
}

  (1)处的this指的是什么呢?它指的就是调用这个方法的对象,如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程,才可以调用P1的同步方法,而对P2而言,P1这个锁与它毫不相干,程序也可能在这种情形下摆脱同步机制的控制,造成数据混乱

  2.同步块,示例代码如下:

public void method3(SomeObject so){
synchronized(so){
//…..
}
}

  这时,锁就是so这个对象,谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时,就可以这样写程序,但当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的instance变量(它得是一个对象)来充当锁:

class Foo implements Runnable{
private byte[] lock = new byte[0]; // 特殊的instance变量
public void methodA() {
synchronized(lock) { //… }
}
//…..
}

  注:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object() 则需要7行操作码。

  3.将synchronized作用于static 函数,示例代码如下:

Class Foo {
public synchronized static void methodA(){ // 同步的static 函数 //….
}
public void methodB() {
synchronized(Foo.class) // class literal(类名称字面常量)
}
}

  代码中的methodB()方法是把class literal作为锁的情况,它和同步的static函数产生的效果是一样的,取得的锁很特别,是当前调用这个方法的对象所属的类(Class,而不再是由这个Class产生的某个具体对象了)。

  如果一个类中定义了一个synchronized的static函数A,也定义了一个synchronized 的instance函数B,那么这个类的同一对象Obj。在多线程中分别访问A和B两个方法时,不会构成同步,因为它们的锁都不一样。A方法的锁是Obj这个对象,而B的锁是Obj所属的那个Class。(经验证在多线程中分别访问A和B两个方法时,不会构成同步)

public class SynTest{
public static void main(String[] args) {
final SynTest mSynTest = new SynTest();
Thread t1 = new Thread(new Runnable() {
public void run() {
mSynTest.methodA();
}
}, "t1");
Thread t2 = new Thread( new Runnable() {
public void run() {
mSynTest.methodB();
}
}, "t2");
t1.start();
t2.start();
}
public synchronized void methodA() {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(5);
} catch (InterruptedException ie) {
}
}
}
public synchronized static void methodB() {
int i = 3;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(5);
} catch (InterruptedException ie) {
}
}
}
}

运行结果为:

 
 
分类: Java知识点

synchronized简介的更多相关文章

  1. (Java 多线程系列)java synchronized详解

    synchronized简介 Java提供了一种内置的锁机制来支持原子性:同步代码块(Synchronized Block).同步代码块包括两部分:一个作为锁对象的引用,一个作为由这个锁保护的代码块. ...

  2. 多线程深入:让你彻底理解Synchronized(转)

    原文:https://www.jianshu.com/p/d53bf830fa09 1. synchronized简介 在学习知识前,我们先来看一个现象: public class Synchroni ...

  3. 4.彻底理解synchronized

    1. synchronized简介 在学习知识前,我们先来看一个现象: public class SynchronizedDemo implements Runnable {    private s ...

  4. 线程同步synchronized和ReentrantLock

    一.线程同步问题的产生及解决方案 问题的产生: Java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),将会导致数据不准确,相互之间产生冲突. 如下例:假设有一个卖票 ...

  5. 这篇文章带你彻底理解synchronized

    本人免费整理了Java高级资料,涵盖了Java.Redis.MongoDB.MySQL.Zookeeper.Spring Cloud.Dubbo高并发分布式等教程,一共30G,需要自己领取.传送门:h ...

  6. 死磕Synchronized底层实现,面试你还怕什么?

    关于synchronized的底层实现,网上有很多文章了.但是很多文章要么作者根本没看代码,仅仅是根据网上其他文章总结.照搬而成,难免有些错误:要么很多点都是一笔带过,对于为什么这样实现没有一个说法, ...

  7. 关于synchronized和ReentrantLock之多线程同步详解

    一.线程同步问题的产生及解决方案 问题的产生: Java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),将会导致数据不准确,相互之间产生冲突. 如下例:假设有一个卖票 ...

  8. 《提升能力,涨薪可待》—Java并发之Synchronized

    Synchronized简介 线程安全是并发编程中的至关重要的,造成线程安全问题的主要原因: 临界资源, 存在共享数据 多线程共同操作共享数据 而Java关键字synchronized,为多线程场景下 ...

  9. Java多线程之synchronized详解

    目录 synchronized简介 同步的原理 对象头与锁的实现 锁的优化与升级 Monitor Record 锁的对比 synchronized简介 synchronized关键字,一般称之为&qu ...

随机推荐

  1. Git@OSC & SSH配置

    #### [ 导入外部Git仓库到中国源代码托管平台(Git@OSC)] 免费代码托管 您可以通过SSH或者HTTP的方式提交和管理代码,也可以通过Web的方式在线阅读,编辑代码与Team@OSC的集 ...

  2. 【百度地图API】——国内首款团购网站的地图插件

    原文:[百度地图API]--国内首款团购网站的地图插件 摘要: 本文介绍了一款应用在团购网站上的地图插件,适用于目前非常流行的团购网站.使用这款地图插件,无需任何编程技术,你就把商家的位置轻松地标注在 ...

  3. easyui datagrid datagrid-filter bug

    问题描述:空字符串.数字过滤 过滤异常 修改js源码: $.fn.datagrid.defaults.operators = { nofilter: { text: 'No Filter' }, co ...

  4. new 和delete

    转自:http://www.cnblogs.com/charley_yang/archive/2010/12/08/1899982.html 一直对C++中的delete和delete[]的区别不甚了 ...

  5. 財智V6.0(完美破解序列号特别版)

    財智V6.0(完美破解序列号特别版)               財智V6.0(完美破解序列号特别版)   財智6是眼下唯一在中央台报道的.比較成熟的国产理財软件.能全面管理家庭的日常收入.消费.储蓄 ...

  6. Responsive Design in 3 Steps

    Responsive web design is no doubt a big thing now. If you still not familiar with responsive design, ...

  7. Front End Books

    Front End Books 记录和推荐一些认为还不错的前端方面的书籍.列入标准: 看过,并觉得值得推荐给大家的. 正在看的,已经觉得不错的,或者听闻别人说不错的. 打算看的,经多人推荐,一致认为必 ...

  8. JavaScript重载解读

    在JavaScript有一个特殊的数据类型---Function种类,JavaScript每个功能Function的类型,例如可以.由于函数是对象.指针,不会与某个函数绑定. <pre name ...

  9. JS判断字符串是否全为中文

    //第一种代码(全为中文则返回"true",不全为中文则返回"false"): <script language="javascript&quo ...

  10. Warning: session_start() [function.session-start]: Cannot send session cookie - headers already sent by

    配置php网站的时候,经常会在页首出现Warning: session_start() [function.session-start]: Cannot send session cache limi ...