java多线程同步确认？

Question

1) 如果使用synchronized(this)，这意味着两个线程中的任何一个都将锁定factor实例并递增val变量值直到循环退出。 所以synchronized(this)在这里意味着我们不应该使用任何其他实例变量。我们必须只使用同步块(synchronized block)内因子实例的变量吗？

2) 如果synchronized(addition)意味着我们只能使用add变量而不是factor实例类的val变量？

关于这个同步块(synchronized block)存在很大的困惑。我的理解是同步块(synchronized block)将锁定对象的实例并保护操作并使其线程安全。但使用不同的实例实际上意味着它应该只保护特定的实例变量而不是任何其他实例变量。任何人都可以深入解释与下面提供的代码相关的概念

class Factor implements Runnable
{
 int val = 0;
Addition addtion = new Addition();

@Override
public void run()
{

    currInsLock();
    diffInsLock();
}

// locking on the current instance which is this
// we will use synchronized(this)

public void currInsLock() 
{
    synchronized (this) 
    {
        for(int i=0;i<100;i++)
        {
                try
                  {
                     Thread.sleep(100);
                  }
                catch (InterruptedException e)
                {
                      e.printStackTrace();
                }   
        System.out.println(Thread.currentThread().getName()+"---val value lock on this obj -->"+val++);

        }
    }
}



// locking on the different instance
public void diffInsLock() 
{
    synchronized (addtion) 
    {

        for(int i=0;i<100;i++)
        {
                try
                  {
                     Thread.sleep(100);
                  }
                catch (InterruptedException e)
                {
                      e.printStackTrace();
                }   
        System.out.println(Thread.currentThread().getName()+"---val value lock on addition obj -->"+val++);
        System.out.println(Thread.currentThread().getName()+"---add value lock on addition obj -->"+addtion.add++);
        }
    }
}

}

加法类:

public class Addition  
{
   public int add=0;
}

主类

 public class ConcurrentDoubt {

 public static void main(String[] args)
{
  Factor factor=new Factor();

  Thread thread1=new Thread(factor);
  Thread thread2=new Thread(factor);

   thread1.start();
   thread2.start();

}
}

Answer 1

你使用什么作为对象的监视器并不重要，它可以是任何对象，我什至会说，理想情况下我们不应该使用 this 作为对象的监视器，而应该使用 private final Object 实例以更好地保护我们的类，因为如果在您的代码之外，我们使用您的类的实例作为对象的监视器，它可能会阻止您的类正常工作。

关键点是，如果您想要保护的内容是在 synchronized block 或使用不同对象的监视器，您的代码不再是线程安全的，因为您不再阻止并发访问或修改。事实上，只有一个线程可以执行受给定对象监视器的同步块(synchronized block)保护的代码，因此如果您有 2 个不同对象的监视器来保护同一事物，则可以有 2 个线程访问/修改您尝试的内容保护。

所以在这里，您使用 this 和 addtion 作为对象的监视器来保护您的成员变量 val，因此您的代码不是线程安全的，您需要使用同一对象的监视器。

假设您想使用 this 作为对象的监视器来保护您的成员变量 val，您的代码应该是:

synchronized (addtion) {
    for(int i=0;i<100;i++) {
        ...
        synchronized (this) {
            System.out.println(
                Thread.currentThread().getName() + 
                "---val value lock on addition obj -->" + val++
            );
        }
        System.out.println(
            Thread.currentThread().getName() + 
            "---add value lock on addition obj -->" + addtion.add++
        );
    }
}