技术控

    今日:94| 主题:49531
收藏本版 (1)
最新软件应用技术尽在掌握

[其他] Java中synchronized的用法

[复制链接]
酗酊而醉 发表于 2016-10-5 08:29:53
53 0

立即注册CoLaBug.com会员,免费获得投稿人的专业资料,享用更多功能,玩转个人品牌!

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
《    编程思想之多线程与多进程(1)》一文详细讲述了线程、进程的关系及在操作系统中的表现,这是多线程学习必须了解的基础。本文将接着讲一下Java线程同步中的一个重要的概念synchronized.  
    synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:
    1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
    2. 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
    3. 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
    4. 修改一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。
    修饰一个代码块  

  
       
  • 一个线程访问一个对象中的synchronized(this)同步代码块时,其他试图访问该对象的线程将被阻塞。我们看下面一个例子:  
  【Demo1】:synchronized的用法

  1. /**
  2. * 同步线程
  3. */
  4. class SyncThread implements Runnable {
  5.    private static int count;

  6.    public SyncThread() {
  7.       count = 0;
  8.    }

  9.    public  void run() {
  10.       synchronized(this) {
  11.          for (int i = 0; i < 5; i++) {
  12.             try {
  13.                System.out.println(Thread.currentThread().getName() + ":" + (count++));
  14.                Thread.sleep(100);
  15.             } catch (InterruptedException e) {
  16.                e.printStackTrace();
  17.             }
  18.          }
  19.       }
  20.    }

  21.    public int getCount() {
  22.       return count;
  23.    }
  24. }
复制代码
SyncThread的调用:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();
复制代码
结果如下:
  1. SyncThread1:0
  2. SyncThread1:1
  3. SyncThread1:2
  4. SyncThread1:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread2:7
  9. SyncThread2:8
  10. SyncThread2:9*
复制代码
   当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时,在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的,因为在执行synchronized代码块时会锁定当前的对象,只有执行完该代码块才能释放该对象锁,下一个线程才能执行并锁定该对象。
    我们再把SyncThread的调用稍微改一下:
   
  1. Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
  2. Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
  3. thread1.start();
  4. thread2.start();
复制代码
结果如下:
  1. SyncThread1:0
  2. SyncThread2:1
  3. SyncThread1:2
  4. SyncThread2:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread1:7
  9. SyncThread1:8
  10. SyncThread2:9
复制代码
不是说一个线程执行synchronized代码块时其它的线程受阻塞吗?为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象,每个对象只有一个锁(lock)与之相关联,而上面的代码等同于下面这段代码:
  1. SyncThread syncThread1 = new SyncThread();
  2. SyncThread syncThread2 = new SyncThread();
  3. Thread thread1 = new Thread(syncThread1, "SyncThread1");
  4. Thread thread2 = new Thread(syncThread2, "SyncThread2");
  5. thread1.start();
  6. thread2.start();
复制代码
这时创建了两个SyncThread的对象syncThread1和syncThread2,线程thread1执行的是syncThread1对象中的synchronized代码(run),而线程thread2执行的是syncThread2对象中的synchronized代码(run);我们知道synchronized锁定的是对象,这时会有两把锁分别锁定syncThread1对象和syncThread2对象,而这两把锁是互不干扰的,不形成互斥,所以两个线程可以同时执行。
    2.当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
    【Demo2】:多个线程访问synchronized和非synchronized代码块   
   
  1. class Counter implements Runnable{
  2.    private int count;

  3.    public Counter() {
  4.       count = 0;
  5.    }

  6.    public void countAdd() {
  7.       synchronized(this) {
  8.          for (int i = 0; i < 5; i ++) {
  9.             try {
  10.                System.out.println(Thread.currentThread().getName() + ":" + (count++));
  11.                Thread.sleep(100);
  12.             } catch (InterruptedException e) {
  13.                e.printStackTrace();
  14.             }
  15.          }
  16.       }
  17.    }

  18.    //非synchronized代码块,未对count进行读写操作,所以可以不用synchronized
  19.    public void printCount() {
  20.       for (int i = 0; i < 5; i ++) {
  21.          try {
  22.             System.out.println(Thread.currentThread().getName() + " count:" + count);
  23.             Thread.sleep(100);
  24.          } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.          }
  27.       }
  28.    }

  29.    public void run() {
  30.       String threadName = Thread.currentThread().getName();
  31.       if (threadName.equals("A")) {
  32.          countAdd();
  33.       } else if (threadName.equals("B")) {
  34.          printCount();
  35.       }
  36.    }
  37. }
复制代码
调用代码:
  1. Counter counter = new Counter();
  2. Thread thread1 = new Thread(counter, "A");
  3. Thread thread2 = new Thread(counter, "B");
  4. thread1.start();
  5. thread2.start();
复制代码
结果如下:
  1. A:0
  2. B count:1
  3. A:1
  4. B count:2
  5. A:2
  6. B count:3
  7. A:3
  8. B count:4
  9. A:4
  10. B count:5
复制代码
上面代码中countAdd是一个synchronized的,printCount是非synchronized的。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时,别的线程可以访问该对象的非synchronized代码块而不受阻塞。
  
       
  • 指定要给某个对象加锁  
  【Demo3】:指定要给某个对象加锁

  1. /**
  2. * 银行账户类
  3. */
  4. class Account {
  5.    String name;
  6.    float amount;

  7.    public Account(String name, float amount) {
  8.       this.name = name;
  9.       this.amount = amount;
  10.    }
  11.    //存钱
  12.    public  void deposit(float amt) {
  13.       amount += amt;
  14.       try {
  15.          Thread.sleep(100);
  16.       } catch (InterruptedException e) {
  17.          e.printStackTrace();
  18.       }
  19.    }
  20.    //取钱
  21.    public  void withdraw(float amt) {
  22.       amount -= amt;
  23.       try {
  24.          Thread.sleep(100);
  25.       } catch (InterruptedException e) {
  26.          e.printStackTrace();
  27.       }
  28.    }

  29.    public float getBalance() {
  30.       return amount;
  31.    }
  32. }

  33. /**
  34. * 账户操作类
  35. */
  36. class AccountOperator implements Runnable{
  37.    private Account account;
  38.    public AccountOperator(Account account) {
  39.       this.account = account;
  40.    }

  41.    public void run() {
  42.       synchronized (account) {
  43.          account.deposit(500);
  44.          account.withdraw(500);
  45.          System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
  46.       }
  47.    }
  48. }
复制代码
调用代码:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();0
复制代码
结果如下:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();1
复制代码
   在AccountOperator 类中的run方法里,我们用synchronized 给account对象加了锁。这时,当一个线程访问account对象时,其他试图访问account对象的线程将会阻塞,直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。
    当有一个明确的对象作为锁时,就可以用类似下面这样的方式写程序。
   
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();2
复制代码
当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的对象来充当锁:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();3
复制代码
说明:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。
  修饰一个方法  

  Synchronized修饰一个方法很简单,就是在方法的前面加synchronized,public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似,只是作用范围不一样,修饰代码块是大括号括起来的范围,而修饰方法范围是整个函数。如将【Demo1】中的run方法改成如下的方式,实现的效果一样。
  *【Demo4】:synchronized修饰一个方法

  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();4
复制代码
   Synchronized作用于整个方法的写法。
    写法一:
   
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();5
复制代码
写法二:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();6
复制代码
写法一修饰的是一个方法,写法二修饰的是一个代码块,但写法一与写法二是等价的,都是锁定了整个方法时的内容。
    在用synchronized修饰方法时要注意以下几点:
    1. synchronized关键字不能继承。
    虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。这两种方式的例子代码如下:
    在子类方法中加上synchronized关键字
   
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();7
复制代码
在子类方法中调用父类的同步方法
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();8
复制代码
       
  • 在定义接口方法时不能使用synchronized关键字。   
  • 构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。  
  修饰一个静态的方法  

  Synchronized也可修饰一个静态方法,用法如下:
  1. SyncThread syncThread = new SyncThread();
  2. Thread thread1 = new Thread(syncThread, "SyncThread1");
  3. Thread thread2 = new Thread(syncThread, "SyncThread2");
  4. thread1.start();
  5. thread2.start();9
复制代码
我们知道静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象。我们对Demo1进行一些修改如下:
  【Demo5】:synchronized修饰静态方法

  1. SyncThread1:0
  2. SyncThread1:1
  3. SyncThread1:2
  4. SyncThread1:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread2:7
  9. SyncThread2:8
  10. SyncThread2:9*0
复制代码
调用代码:
  1. SyncThread syncThread1 = new SyncThread();
  2. SyncThread syncThread2 = new SyncThread();
  3. Thread thread1 = new Thread(syncThread1, "SyncThread1");
  4. Thread thread2 = new Thread(syncThread2, "SyncThread2");
  5. thread1.start();
  6. thread2.start();
复制代码
结果如下:
  1. SyncThread1:0
  2. SyncThread1:1
  3. SyncThread1:2
  4. SyncThread1:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread2:7
  9. SyncThread2:8
  10. SyncThread2:9*2
复制代码
syncThread1和syncThread2是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method,而静态方法是属于类的,所以syncThread1和syncThread2相当于用了同一把锁。这与Demo1是不同的。
  修饰一个类  

  Synchronized还可作用于一个类,用法如下:
  1. SyncThread1:0
  2. SyncThread1:1
  3. SyncThread1:2
  4. SyncThread1:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread2:7
  9. SyncThread2:8
  10. SyncThread2:9*3
复制代码
   我们把Demo5再作一些修改。
    【Demo6】:修饰一个类   
   
  1. SyncThread1:0
  2. SyncThread1:1
  3. SyncThread1:2
  4. SyncThread1:3
  5. SyncThread1:4
  6. SyncThread2:5
  7. SyncThread2:6
  8. SyncThread2:7
  9. SyncThread2:8
  10. SyncThread2:9*4
复制代码
其效果和【Demo5】是一样的,synchronized作用于一个类T时,是给这个类T加锁,T的所有对象用的是同一把锁。
    A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。
    B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。
    C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。
        参考资料:
          http://blog.csdn.net/chenguang79/article/details/677720   
    http://developer.51cto.com/art/200906/132354.htm
友荐云推荐




上一篇:Apex.sh?
下一篇:Embedded Reviews at Yelp
酷辣虫提示酷辣虫禁止发表任何与中华人民共和国法律有抵触的内容!所有内容由用户发布,并不代表酷辣虫的观点,酷辣虫无法对用户发布内容真实性提供任何的保证,请自行验证并承担风险与后果。如您有版权、违规等问题,请通过"联系我们"或"违规举报"告知我们处理。

*滑动验证:
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

我要投稿

推荐阅读

扫码访问 @iTTTTT瑞翔 的微博
回页顶回复上一篇下一篇回列表手机版
手机版/CoLaBug.com ( 粤ICP备05003221号 | 文网文[2010]257号 )|网站地图 酷辣虫

© 2001-2016 Comsenz Inc. Design: Dean. DiscuzFans.

返回顶部 返回列表