Java同步锁一个技巧

Synchronized 同步
  Java5开始虽然引入了高效的 Concurrent 并发包，但同步 synchroize 在一些场合还是需要使用的。
比较典型和我们通常的做法是对某个类成员变量加同步锁，这个变量一般是存储关键数据的。

但许多开源框架中有下面的用法， 例如：
Cglib 中的 MethodProxy ：

package net.sf.cglib.proxy;
public class MethodProxy {
    private Signature sig1;
    private Signature sig2;
   private final Object initLock = new Object();

  private void init()
   {
        if (fastClassInfo == null)
        {
            synchronized (initLock)
            {
                if (fastClassInfo == null)
                {
                    CreateInfo ci = createInfo;

                    FastClassInfo fci = new FastClassInfo();
                   .................
                    fastClassInfo = fci;
                }
            }
        }
    }

大家不用关心MethodProxy 是做什么的，只需关注 private final Object initLock = new Object();
其中，initLock 对象不用来存储数据，而仅仅用来做同步锁对象，这样可以较小锁的粒度，非常高效。
因此, synchronized(this), synchroniezd( 存储用成员变量) 都可以替换为这个模式。

JDK 源码中也有很多这样的模式的范例可以参考。

评论

35 楼 pengjunwu 2010-09-07  

zli.ray 写道

lz的 lock对象，我用普通的

private static Object lock = new Object();

来代替可以吗？

应该要加 static的 因为也要保证这个同步锁（一个共享的对象）是同一个锁！

34 楼 狂放不羁 2010-05-04  

不加synchroinzed不能保证可见性，有可能引用是最新的值，但是对象不是。因此需要Voliate来保证内存可见性。

33 楼 tomspiders 2010-05-02  

单例不要用懒惰，也不要用双检锁，累赘，罗嗦
http://www.ibm.com/developerworks/cn/java/j-dcl.html

32 楼 mic_scofield 2010-04-19  

超级潜水艇 写道

用单独的锁对象是要比锁整个类性能要高出很多。
平常大家直接用在方法上的synchronized 实际上是锁定这个类。
那么不相关业务的锁定都同时锁定该类的话，那么有可能有这样的情景，即两个业务互不相干的，但是却要相互同步（因为方法上都用了synchronized ）

一般定义一个类的私有变量来实现同步，这样可以避免同时锁住类

31 楼 jayming 2010-03-30  

dennis_zane 写道

扯淡帖，不存储数据就变成锁粒度更小了？synchronized(this)跟你专门搞个object来用没有本质区别，都是对象锁。

我也觉得没本质区别

30 楼 linkerlin 2010-03-30  

Double-checked locking 的传统写法没有volatile修饰。

29 楼 linkerlin 2010-03-30  

即使是java 1.5也是要用volatile的。

28 楼 wkoffee 2010-03-30  

linkerlin 写道

double lock在java里是失效的。
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

你仔细看完这篇文章的话就知道java1.5之后double check locking是没有问题的

27 楼 dennis_zane 2010-03-30  

扯淡帖，不存储数据就变成锁粒度更小了？synchronized(this)跟你专门搞个object来用没有本质区别，都是对象锁。

26 楼 linkerlin 2010-03-30  

double lock在java里是失效的。
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

25 楼 linkerlin 2010-03-30  

千万不要锁this.

24 楼 nishizhutoua 2010-03-30  

很明确的说一句,双锁机制也不是完全可靠.

23 楼 Mybeautiful 2010-03-28  

超级潜水艇 写道

Mybeautiful 写道

超级潜水艇 写道

。。。。。。
平常大家直接用在方法上的synchronized 实际上是锁定这个类。 ）

锁定的不是这个类，是这个类当前的对象。

怪我说法不科学。。
静态方法上加synchronized 锁定该类。
实例方法上加synchronized 锁定该实例。

对不起，我想在罗嗦一下，虽然我们都了解其意思，但是有必要对概率进行澄清。

“静态方法上加synchronized 锁定该类。”这句话有待探讨，类是个静态的概念，程序运行起来后没有类，只有对象。 所以这种情况到底锁的是哪个对象，还真不太好表述。就是运行时的 ClassName.class 或 object.getClass()  这个对象吧.

22 楼 徐风子 2010-02-02  

raymond2006k 写道

if (fastClassInfo == null)
{
    synchronized (initLock)
    {
        if (fastClassInfo == null)
        {
            CreateInfo ci = createInfo;

            FastClassInfo fci = new FastClassInfo();
           .................
            fastClassInfo = fci;
        }
    }
}

不会有所谓的“双检锁”问题吗？
有的人又说java虚拟可以处理了双检锁问题了，疑惑中……

21 楼 lzyzizi 2010-02-01  

加一个object只是多一个信号量而已，如果你有很多信号量这样实现会很不方便，我记得conurrent包里可以使用condition接口来实现你这种情况。

感觉这个代码都是concurrent包出来之前写的， tomcat中也有类似代码。因为一个monitor不够用。

20 楼 readymydream 2010-02-01  

neptune 写道

hommy8 写道

这里重点不在双锁机制，而是锁的粒度...的确应该如LZ说的，锁的粒度达到了最小化了

还有锁的粒度跟小的你信不信？

ls的来一个例子让大家看看

19 楼 neptune 2010-02-01  

hommy8 写道

这里重点不在双锁机制，而是锁的粒度...的确应该如LZ说的，锁的粒度达到了最小化了

还有锁的粒度跟小的你信不信？

18 楼 raymond2006k 2010-02-01  

runshine 写道

vlinux 写道

能提供一下如何使用这个Reference呢？我乍看一下不明白使用场合呢

public class MethodProxy
{
   private int i,j;
   private final Object initLocki = new Object();
   private final Object initLockj = new Object();

   public void addi()
   {
            synchronized (initLocki)
            {
                i++;
            }
   }

   public void subi()
   {
            synchronized (initLocki)
            {
                i--;
            }
   }

   public void addj()
   {
            synchronized (initLockj)
            {
                j++;
            }
   }

   public void subj()
   {
            synchronized (initLockj)
            {
                j--;
            }
   }
}

不知道这么举例理解合不合适,我想应用场合大约是这样
i与j的操作是两个互不相关的操作,若加同一对象锁或this,就会出现i与j操作的互斥,性能会有不必要的损失
仅仅对同一操作addi、subi及addj、subj加同一对象锁，这样既不存在隐患，且能提高性能

太有才了，通俗易懂的说明了问题，很适合做培训和写技术文章啊，呵呵。
自己的举例能力，真是汗颜，向你学习。

17 楼 runshine 2010-02-01  

vlinux 写道

能提供一下如何使用这个Reference呢？我乍看一下不明白使用场合呢

public class MethodProxy
{
   private int i,j;
   private final Object initLocki = new Object();
   private final Object initLockj = new Object();

   public void addi()
   {
            synchronized (initLocki)
            {
                i++;
            }
   }

   public void subi()
   {
            synchronized (initLocki)
            {
                i--;
            }
   }

   public void addj()
   {
            synchronized (initLockj)
            {
                j++;
            }
   }

   public void subj()
   {
            synchronized (initLockj)
            {
                j--;
            }
   }
}

不知道这么举例理解合不合适,我想应用场合大约是这样
i与j的操作是两个互不相关的操作,若加同一对象锁或this,就会出现i与j操作的互斥,性能会有不必要的损失
仅仅对同一操作addi、subi及addj、subj加同一对象锁，这样既不存在隐患，且能提高性能

16 楼 hommy8 2010-02-01  

这里重点不在双锁机制，而是锁的粒度...的确应该如LZ说的，锁的粒度达到了最小化了