同步块问题？

Question

您好我有多种方法，我需要synchronized块在所有的方法是这样一类：

public class Test2 { 
    private Object mutex=new Object(); 
    private OtherClass obj=new OtherClass(); 

    public void method1(){ 
     //do some stuff 
     synchronized (mutex) { 
      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 

    public void method2(){ 
     //do some stuff 
     synchronized (mutex) { 
      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 

    public void method3(){ 
     //do some stuff 
     synchronized (mutex) { 
      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 

    public void method4(){ 
     //do some stuff 
     synchronized (mutex) { 

      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 
} 

我使用互斥块同步，所以会发生什么，如果正在使用method1时，其他method2同步块等待，直到流出同步块method1。

我不希望发生这种情况，所以我该怎么办？我知道，因为我正在为所有方法使用互斥锁，所以它锁定了method2同步块。我想知道我该怎么做才能删除它？我应该为每种方法创建成员变量吗？还是有其他解决方法？

我希望其他线程只有在调用相同的方法时才会等待。就像两个线程对mehod1进行分类，因此第二个线程应该等待。但如果第二个线程调用method2，它不应该等待。

Answer 1

根据您的评论来判断我假设您想要按方法同步而不是按对象。在这种情况下，最简单的方法是为每个方法声明一个单独的监视器对象，即mutex1,mutex2等。

Answer 2

您应该在method2方法中使用另一个mutext。

Answer 3

只需在每种方法中使用不同的监视器。

public class Test2 { 
    private Object mutex1 = new Object(), mutex2 = new Object(); 
    private OtherClass obj=new OtherClass(); 

    public void method1() { 
     //do some stuff 
     synchronized (mutex1) { 
      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 

    public void method2() { 
     //do some stuff 
     synchronized (mutex2) { 
      obj.//some method 
      //do some stuff 
     } 
     //do other stuff 
    } 
} 

如果你有很多方法，你也可以将它们打包在一个数组中。

Answer 4

如果您想实现这个目标并对它们进行同步，您必须为每个方法调用使用不同的监视器对象（代码中的mutex）。如果你有很多方法，你可以使用一些集合类握住你的互斥对象：

public class Test2 { 
    private Object[] mutexes=new Object[2]; 
    private OtherClass obj=new OtherClass(); 

    private synchronized Object getMutex(int i) { 
     if(mutexes[i] == null) { 
      mutexes[i] = new Object(); 
     } 
     return mutexes[i]; 
    } 

    public void method1(){ 
     //do some stuff 
     synchronized (getMutex(1)) { 
      //do some stuff 
     } 
     //do other stuff 
    } 

    public void method2(){ 
     //do some stuff 
     synchronized (getMutex(2)) { 
      //do some stuff 
     } 
     //do other stuff 
    } 
} 

请注意，如果您同步在每个方法的基础，但每种方法从访问同一个对象（obj你的情况）​​块，对该特定对象的访问仍然不是线程安全的。

的另一个选项是初始化在构造函数中的所有互斥锁代替点播在getMutex()方法创建它们的：

public Test() { 
    for(int i = 0; i < mutexes.length()) { 
     mutexes[i] = new Object(); 
    } 
}