Java 同步和线程

Question

import java.util.Random;

public class ClassA{
  int a = 0, b = 10;
  Random rand = new Random();

  public synchronized void add(){
      if (a < 10){ 
         a++;
         b--;
      };
  }

  public synchronized void subtract(){
      if (b < 10){ 
         b++;
         a--;
      }
  }
  
  public synchronized boolean check(){
     return a + b == 10;
  }
  
  
  public static void main(String args[]){
      
      ClassA a = new ClassA();
      
      B ba = new B(a);
      B bb = new B(a);
      
       //notice these two threads are not associated with the object a!
      Thread t11 = new Thread(bb);
      Thread t22 = new Thread(ba);
      t11.start(); 
      t22.start();
  }
}


class B implements Runnable{
    ClassA a;
    
    B(ClassA a){
        this.a = a;
    }
   
    @Override
    public void run(){
        while (a.check()){
          if (a.rand.nextInt(2) == 1)
              a.subtract();
          else
              a.add();
      } System.out.print("Out of sync");
    }
}

我试图更好地理解Java多线程。所以，我知道这句话说只有一个线程可以访问一个对象实例，从而调用该实例的方法（例如，在这种情况下，类 class A 中的减法方法。

但是，当你仍然有相同的类 A 实例时，会发生什么，但两个线程与不同的类 B 相关联，完全试图调用 a 的方法？我以为不同步的消息永远不会被打印出来，但它确实打印出来了。毕竟，仍然只有一个对象实例 a，这是否意味着同步不适用于此示例？

Answer 1

在您的情况下，out of sync永远不会被打印，因为对于您的情况，多线程是正确实现的：通过在方法上使用同步关键字，执行一系列操作并因此不是原子的关键方法的行为类似于原子方法。

假设一个代码块被声明为synchronized（x）。进入该代码块的第一个线程获得对象＜code＞x＜/code＞的锁，并愉快地执行该代码块。

任何尝试进入同一对象 x 上的块的非第一个线程都将通过将线程放入 x 的锁定池来“挂起”。一旦当前具有锁的线程离开同步 （x） 块，锁池中的随机线程将成为执行该块的下一个线程。

当在实例方法上使用< code>synchronized时，它实际上等同于用< code>synchronized (this)包装方法的全部内容。(对于< code>static方法，它将是封闭类的类对象。)

因此，在您的例子中，有一个类＜code＞A＜/code＞的实例，所有同步都发生在它上面。

如果您想查看不同步消息，请尝试删除同步关键字。然后一段时间后，您应该会看到预期的不同步消息。

旁注：

< li >因为< code >不同步是一条消息，所以它可能应该打印在< code>System.err上，而不是< code>System.out上。 < li >可以使用< code > a . rand . nextint(2)= = 1 代替< code > a . rand . nextboolean()。 < li >让< code>class A的< code>class B访问字段< code>rand会破坏封装，您可能希望给< code>class A一个方法< code>randomBoolean()，该方法< code >返回rand.nextBoolean()，并从< code>class B中调用该方法< code>randomBoolean()。 < li >相同的变量名在不同的上下文中具有不同的含义可能会引起混淆。在< code>a类中，变量< code>a和< code>b表示两个数字，在其他上下文中，变量< code>a和< code>b指的是< code>a类和< code>b类的实例。考虑将< code > A类字段重命名为其他名称，如< code >数字1和< code >数字2。