Question

如果我在同一个类中有2个同步方法，但每个方法访问不同的变量，那么2个线程可以同时访问这两个方法吗？锁是否发生在对象上，或者它是否与synchronized方法中的变量一样具体？

示例：

class X {

    private int a;
    private int b;

    public synchronized void addA(){
        a++;
    }

    public synchronized void addB(){
        b++;
    }

}

2个线程可以同时访问同一个执行x.addA(）和x.addB()的X类实例吗？

Answer 1

如果您将方法声明为同步（正如您通过键入public synchronized void addA()所做的那样），则在整个对象上进行同步，因此从同一对象访问不同变量的两个线程将无论如何阻止对方。

如果您希望一次仅同步一个变量，那么两个线程在访问不同变量时不会相互阻塞，您可以在synchronized ()块中单独同步它们。如果a和b是对象引用，您将使用：

public void addA() {
    synchronized( a ) {
        a++;
    }
}
public void addB() {
    synchronized( b ) {
        b++;
    }
}

但由于他们是原始人，你不能这样做。

我建议你改用AtomicInteger：

import java.util.concurrent.atomic.AtomicInteger;
class X {
    AtomicInteger a;
    AtomicInteger b;
    public void addA(){
        a.incrementAndGet();
    }
    public void addB(){ 
        b.incrementAndGet();
    }
}

Answer 2

对方法声明进行同步是这样的语法糖：

 public void addA() {
     synchronized (this) {
          a++;
     }
  }

在静态方法上，它是语法糖：

 ClassA {
     public static void addA() {
          synchronized(ClassA.class) {
              a++;
          }
 }

我认为如果Java设计人员知道现在对同步有什么了解，他们就不会添加语法糖，因为它往往会导致并发性的不良实现。

Answer 3

访问的锁是在对象上，而不是在方法上。在该方法中访问哪些变量是无关紧要的。

向方法添加“synchronized”意味着运行代码的线程必须在继续之前获取对象的锁定。添加“静态同步”意味着运行代码的线程必须在继续之前获取类对象的锁定。或者，您可以将代码包装在这样的块中：

public void addA() {
    synchronized(this) {
        a++;
    }
}

以便您可以指定必须获取其锁定的对象。

如果您想避免锁定包含对象，可以选择：

using synchronized blocks that specify different locks
制作a和b原子（使用java.util.concurrent.atomic）

Answer 4

From the Java SE essentials on synchronized methods：

首先，对同一对象的两个同步方法的调用不可能进行交错。当一个线程正在为对象执行同步方法时，所有其他线程都会调用同一对象的同步方法阻塞（暂停执行），直到第一个线程完成对象为止。

来自Java SE essentials on synchronized blocks：

同步语句对于通过细粒度同步提高并发性也很有用。例如，假设类MsLunch有两个从不一起使用的实例字段c1和c2。必须同步这些字段的所有更新，但没有理由阻止c1的更新与c2 的更新交错 - 这样做会通过创建不必要的阻塞来减少并发性。 我们不是使用同步方法或使用与此相关联的锁，而是仅创建两个对象以提供锁定。

（强调我的。）

你有两个变量no-interleaved。因此，您希望同时访问来自不同线程的每个线程。你需要定义锁不在对象类本身上，而是在类Object上定义如下（例如来自第二个Oracle链接）：

public class MsLunch { private long c1 = 0; private long c2 = 0; private Object lock1 = new Object(); private Object lock2 = new Object(); public void inc1() { synchronized(lock1) { c1++; } } public void inc2() { synchronized(lock2) { c2++; } } }

Answer 5

来自oracle文档link

使方法同步有两个影响：

首先，对同一对象的两个同步方法的调用不可能进行交错。当一个线程正在为对象执行同步方法时，所有其他线程都会调用同一对象的同步方法阻塞（暂停执行），直到第一个线程完成对象为止。

其次，当synchronized方法退出时，它会自动与同一对象的同步方法的任何后续调用建立一个before-before关系。这可以保证对所有线程都可以看到对象状态的更改

查看本文档page以了解内部锁和锁定行为。

这将回答您的问题：在同一个对象x上，当其中一个同步方法执行时，您无法同时调用x.addA（）和x.addB（）进展。

Answer 6

您可以执行以下操作。在这种情况下，您使用a和b上的锁来同步而不是锁定“this”。我们不能使用int，因为原始值没有锁，所以我们使用Integer。

class x{
   private Integer a;
   private Integer b;
   public void addA(){
      synchronized(a) {
         a++;
      }
   }
   public synchronized void addB(){
      synchronized(b) {
         b++;
      }
   }
}

Answer 7

如果您有一些未同步的方法，并且正在访问和更改实例变量。在您的示例中：

 private int a;
 private int b;

当其他线程位于同一对象的synchronized方法中并且可以更改实例变量时，任意数量的线程都可以同时访问这些非同步方法。例如： -

 public void changeState() {
      a++;
      b++;
    }

您需要避免非同步方法正在访问实例变量并更改它的情况，否则无法使用同步方法。

在以下场景中： -

class X {

        private int a;
        private int b;

        public synchronized void addA(){
            a++;
        }

        public synchronized void addB(){
            b++;
        }
     public void changeState() {
          a++;
          b++;
        }
    }

只有一个线程可以在addA或addB方法中，但同时任意数量的线程都可以进入changeState方法。没有两个线程可以同时输入addA和addB（因为对象级别锁定）但同时任意数量的线程都可以进入changeState。

Answer 8

这个例子（尽管不是很好）可以提供对锁定机制的更多了解。如果 incrementA 同步，并且 incrementB 未同步，那么 incrementB 将是尽快执行，但如果 incrementB 也同步那么它必须'等待' incrementA 完成，然后 incrementB >可以做好自己的工作。

两个方法都被调用到单个实例 - 对象，在这个例子中它是： job ，而'竞争'线程是 aThread 和 main 。

尝试 incrementB 中的“同步”，如果没有它，您会看到不同的结果。如果 incrementB 是“同步< / strong>'然后它必须等待 incrementA （）才能完成。每个变体运行几次。

200dp

Answer 9

是的，它会阻止另一个方法，因为synchronized方法适用于指向的 WHOLE 类对象....但无论如何它会阻止其他线程执行 ONLY 在它进入的任何方法addA或addB中执行求和时，因为当它完成时...一个线程将自由对象，另一个线程将访问另一个方法，等等完美地工作。 / p>

我的意思是“同步”正是为了阻止其他线程在特定代码执行时访问另一个线程。所以这个代码最终会很精细。

最后要注意的是，如果存在'a'和'b'变量，而不仅仅是一个唯一变量'a'或其他任何名称，则无需同步此方法，因为它非常安全地访问其他变量（其他内存位置）。

class X {

private int a;
private int b;

public void addA(){
    a++;
}

public void addB(){
    b++;
}}

也会起作用

Answer 10

这可能不起作用，因为从Integer到int和反向的装箱和自动装箱依赖于JVM，如果它们在-128到127之间，很可能会将两个不同的数字散列到相同的地址。

Answer 11

在Java同步中，如果线程想要进入同步方法，它将获取该对象的所有同步方法的锁，而不仅仅是线程正在使用的一个同步方法。因此，执行addA（）的线程将获得对addA（）和addB（）的锁定，因为这两者都是同步的。因此具有相同对象的其他线程无法执行addB（）。

Java同步方法锁定对象或方法？

11 个答案: