首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >synchronized锁住的是代码还是对象

synchronized锁住的是代码还是对象

作者头像
用户1205080
发布2018-09-12 10:06:24
7300
发布2018-09-12 10:06:24
举报
文章被收录于专栏:编码前线编码前线

在Java中,synchronized关键字是用来控制线程同步的,就是在多线程的环境下,控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上,也可以加在方法上。

关键是,不要认为给方法或者代码段加上synchronized就万事大吉,看下面一段代码:

class Sync {

  1. public synchronized void test() {
  2. System.out.println("test开始..");
  3. try {
  4. Thread.sleep(1000);
  5. } catch (InterruptedException e) {
  6. e.printStackTrace();
  7. }
  8. System.out.println("test结束..");
  9. }
  10. }
  11. class MyThread extends Thread {
  12. public void run() {
  13. Sync sync = new Sync();
  14. sync.test();
  15. }
  16. }
  17. public class Main {
  18. public static void main(String[] args) {
  19. for (int i = 0; i < 3; i++) {
  20. Thread thread = new MyThread();
  21. thread.start();
  22. }
  23. }
  24. }

运行结果: test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

可以看出来,上面的程序起了三个线程,同时运行Sync类中的test()方法,虽然test()方法加上了synchronized,但是还是同时运行起来,貌似synchronized没起作用。

将test()方法上的synchronized去掉,在方法内部加上synchronized(this):

  1. public void test() {
  2. synchronized(this){
  3. System.out.println("test开始..");
  4. try {
  5. Thread.sleep(1000);
  6. } catch (InterruptedException e) {
  7. e.printStackTrace();
  8. }
  9. System.out.println("test结束..");
  10. }
  11. }

运行结果: test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

一切还是这么平静,没有看到synchronized起到作用。

实际上,synchronized(this)以及非static的synchronized方法(至于static synchronized方法请往下看),只能防止多个线程同时执行同一个对象的同步代码段。

回到本文的题目上:synchronized锁住的是代码还是对象。答案是:synchronized锁住的是括号里的对象,而不是代码。对于非static的synchronized方法,锁的就是对象本身也就是this。

当synchronized锁住一个对象后,别的线程如果也想拿到这个对象的锁,就必须等待这个线程执行完成释放锁,才能再次给对象加锁,这样才达到线程同步的目的。即使两个不同的代码段,都要锁同一个对象,那么这两个代码段也不能在多线程环境下同时运行。

所以我们在用synchronized关键字的时候,能缩小代码段的范围就尽量缩小,能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度,使代码更大程度的并发。原因是基于以上的思想,锁的代码段太长了,别的线程是不是要等很久,等的花儿都谢了。当然这段是题外话,与本文核心思想并无太大关联。

再看上面的代码,每个线程中都new了一个Sync类的对象,也就是产生了三个Sync对象,由于不是同一个对象,所以可以多线程同时运行synchronized方法或代码段。

为了验证上述的观点,修改一下代码,让三个线程使用同一个Sync的对象。

  1. class MyThread extends Thread {
  2. private Sync sync;
  3. public MyThread(Sync sync) {
  4. this.sync = sync;
  5. }
  6. public void run() {
  7. sync.test();
  8. }
  9. }
  10. public class Main {
  11. public static void main(String[] args) {
  12. Sync sync = new Sync();
  13. for (int i = 0; i < 3; i++) {
  14. Thread thread = new MyThread(sync);
  15. thread.start();
  16. }
  17. }
  18. }

运行结果: test开始.. test结束.. test开始.. test结束.. test开始.. test结束..

可以看到,此时的synchronized就起了作用。

那么,如果真的想锁住这段代码,要怎么做?也就是,如果还是最开始的那段代码,每个线程new一个Sync对象,怎么才能让test方法不会被多线程执行。

解决也很简单,只要锁住同一个对象不就行了。例如,synchronized后的括号中锁同一个固定对象,这样就行了。这样是没问题,但是,比较多的做法是让synchronized锁这个类对应的Class对象。

  1. class Sync {
  2. public void test() {
  3. synchronized (Sync.class) {
  4. System.out.println("test开始..");
  5. try {
  6. Thread.sleep(1000);
  7. } catch (InterruptedException e) {
  8. e.printStackTrace();
  9. }
  10. System.out.println("test结束..");
  11. }
  12. }
  13. }
  14. class MyThread extends Thread {
  15. public void run() {
  16. Sync sync = new Sync();
  17. sync.test();
  18. }
  19. }
  20. public class Main {
  21. public static void main(String[] args) {
  22. for (int i = 0; i < 3; i++) {
  23. Thread thread = new MyThread();
  24. thread.start();
  25. }
  26. }
  27. }

运行结果: test开始.. test结束.. test开始.. test结束.. test开始.. test结束..

上面代码用synchronized(Sync.class)实现了全局锁的效果。

static synchronized方法,static方法可以直接类名加方法名调用,方法中无法使用this,所以它锁的不是this,而是类的Class对象,所以,static synchronized方法也相当于全局锁,相当于锁住了代码段。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2018-08-25,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 编码前线 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档