zoukankan      html  css  js  c++  java
  • java中synchronized(同步代码块和同步方法)详解及区别

    java中synchronized(同步代码块和同步方法)详解及区别

    问题的由来:

    看到这样一个面试题:

    1
    2
    3
    4
    5
    6
    //下列两个方法有什么区别
    public synchronized void method1(){}
     
    public void method2(){
     synchronized (obj){}
    }

    synchronized用于解决同步问题,当有多条线程同时访问共享数据时,如果进行同步,就会发生错误,Java提供的解决方案是:只要将操作共享数据的语句在某一时段让一个线程执行完,在执行过程中,其他线程不能进来执行可以。解决这个问题。这里在用synchronized时会有两种方式,一种是上面的同步方法,即用synchronized来修饰方法,另一种是提供的同步代码块。

    这里总感觉怪怪的,这两种方法有什么区别呢,基础学得不好,于是就动手做了个简单的测试,代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class SynObj {
      public synchronized void methodA() {
        System.out.println("methodA.....");
        try {
          Thread.sleep(5000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
     
      public void methodB() {
        synchronized(this) {
          System.out.pritntln("methodB.....");
        }
      }
     
      public void methodC() {
        String str = "sss";
        synchronized (str) {
          System.out.println(    "methodC.....");
        }
      }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    public class TestSyn {
      public static void main(String[] args) {
        final SynObj obj = new SynObj();
     
        Thread t1 = new Thread(new Runnable() {
          @Override
          public void run() {
            obj.methodA();
          }
        });
        t1.start();
     
        Thread t2 = new Thread(new Runnable() {
          @Override
          public void run() {
            obj.methodB();
          }
        });
        t2.start();
     
        Thread t3 = new Thread(new Runnable() {
          @Override
          public void run() {
            obj.methodC();
          }
        });
        t3.start();
      }
    }

    这段小代码片段打印结果如下:

    1
    2
    3
    4
    methodA.....
    methodC.....
    //methodB会隔一段时间才会打印出来
    methodB.....

    这段代码的打印结果是,methodA…..methodC…..会很快打印出来,methodB…..会隔一段时间才打印出来,那么methodB为什么不能像methodC那样很快被调用呢?

    在启动线程1调用方法A后,接着会让线程1休眠5秒钟,这时会调用方法C,注意到方法C这里用synchronized进行加锁,这里锁的对象是str这个字符串对象。但是方法B则不同,是用当前对象this进行加锁,注意到方法A直接在方法上加synchronized,这个加锁的对象是什么呢?显然,这两个方法用的是一把锁。

    *由这样的结果,我们就知道这样同步方法是用什么加锁的了,由于线程1在休眠,这时锁还没释放,导致线程2只有在5秒之后才能调用方法B,由此,可知两种加锁机制用的是同一个锁对象,即当前对象。 

    另外,同步方法直接在方法上加synchronized实现加锁,同步代码块则在方法内部加锁,很明显,同步方法锁的范围比较大,而同步代码块范围要小点,一般同步的范围越大,性能就越差,一般需要加锁进行同步的时候,肯定是范围越小越好,这样性能更好*。

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    原文链接:http://blog.csdn.net/h_gao/article/details/52266950

  • 相关阅读:
    JS函数节流
    JS中多种方式创建对象
    javascript的几种继承
    多进程基本概念
    APUE(1)——UNIX基本概念
    pthread
    使用TortoiseGit,设置ssh方式连接git仓库。
    mac系统下用ssh方式连接git仓库
    webstorm2017.02版本如何使用material theme
    谷歌浏览器的字体问题
  • 原文地址:https://www.cnblogs.com/dcxmaozi/p/7133341.html
Copyright © 2011-2022 走看看