私人建造者避免比赛条件

Question

我正在阅读本书第Java Concurrency in Practice4.3.5节

  @ThreadSafe
  public class SafePoint{

       @GuardedBy("this") private int x,y;

       private SafePoint (int [] a) { this (a[0], a[1]); }

       public SafePoint(SafePoint p) { this (p.get()); }

       public SafePoint(int x, int y){
            this.x = x;
            this.y = y;
       }

       public synchronized int[] get(){
            return new int[] {x,y};
       }

       public synchronized void set(int x, int y){
            this.x = x;
            this.y = y;
       }

  }

我不清楚它在哪里说

私有构造函数的存在是为了避免如果将复制构造函数实现为（px，py）时会发生竞争情况。这是私有构造函数捕获习语的一个示例（Bloch和Gafter，2005）。

我知道它提供了一个同时在数组中一次获取x和y的getter，而不是为每个数组分别获取一个getter，因此调用方将看到一致的值，但是为什么要使用private构造函数呢？这有什么窍门

Answer 1

这里已经有很多答案了，但是我真的很想深入研究一些细节（就我所知，这是我的全部）。我会强烈建议您运行答案中出现的每个示例，以亲自了解情况如何以及原因。

要了解解决方案，您需要首先了解问题。

假设SafePoint类实际上如下所示：

class SafePoint {
    private int x;
    private int y;

    public SafePoint(int x, int y){
        this.x = x;
        this.y = y;
    }

    public SafePoint(SafePoint safePoint){
        this(safePoint.x, safePoint.y);
    }

    public synchronized int[] getXY(){
        return new int[]{x,y};
    }

    public synchronized void setXY(int x, int y){
        this.x = x;
        //Simulate some resource intensive work that starts EXACTLY at this point, causing a small delay
        try {
            Thread.sleep(10 * 100);
        } catch (InterruptedException e) {
         e.printStackTrace();
        }
        this.y = y;
    }

    public String toString(){
      return Objects.toStringHelper(this.getClass()).add("X", x).add("Y", y).toString();
    }
}

哪些变量创建了该对象的状态？其中只有两个：x，y。它们受到某种同步机制的保护吗？好吧，它们是通过内在锁，通过synced关键字进行的-
至少在setter和getter中。他们在其他任何地方被“感动”吗？当然在这里：

public SafePoint(SafePoint safePoint){
    this(safePoint.x, safePoint.y);
}

您在这里所做的就是从对象中 读取 。为了使一个类是线程安全的，您必须协调 对该 类的读/写访问，或 在相同的锁上进行同步。
但是这里没有发生任何事情。该 setXY 方法确实是同步的，但克隆的构造不是，因此调用这两个可以在非线程安全的方式来完成。我们可以上这节课吗？

让我们尝试一下：

public class SafePointMain {
public static void main(String[] args) throws Exception {
    final SafePoint originalSafePoint = new SafePoint(1,1);

    //One Thread is trying to change this SafePoint
    new Thread(new Runnable() {
        @Override
        public void run() {
            originalSafePoint.setXY(2, 2);
            System.out.println("Original : " + originalSafePoint.toString());
        }
    }).start();

    //The other Thread is trying to create a copy. The copy, depending on the JVM, MUST be either (1,1) or (2,2)
    //depending on which Thread starts first, but it can not be (1,2) or (2,1) for example.
    new Thread(new Runnable() {
        @Override
        public void run() {
            SafePoint copySafePoint = new SafePoint(originalSafePoint);
            System.out.println("Copy : " + copySafePoint.toString());
        }
    }).start();
}
}

输出很容易是这样的：

 Copy : SafePoint{X=2, Y=1}
 Original : SafePoint{X=2, Y=2}

这是逻辑，因为一个线程update ==写入我们的对象，而另一个线程正在读取它。它们不会在某个通用锁上同步，因此不会同步输出。

解？

• 同步构造函数，以便读取将在相同的锁上进行同步，但是Java中的构造函数不能使用synced关键字-这当然是逻辑。

• 可能使用其他锁，例如可重入锁（如果无法使用synced关键字）。但这也行不通，因为 构造函数中的第一条语句必须是对此this / super的调用 。如果我们实现一个不同的锁，那么第一行必须是这样的：

lock.lock（）//其中锁是ReentrantLock，出于上述原因，编译器将不允许这样做。

• 如果使构造函数成为方法怎么办？当然可以！

参见此代码示例

/*
 * this is a refactored method, instead of a constructor
 */
public SafePoint cloneSafePoint(SafePoint originalSafePoint){
     int [] xy = originalSafePoint.getXY();
     return new SafePoint(xy[0], xy[1]);    
}

呼叫看起来像这样：

 public void run() {
      SafePoint copySafePoint = originalSafePoint.cloneSafePoint(originalSafePoint);
      //SafePoint copySafePoint = new SafePoint(originalSafePoint);
      System.out.println("Copy : " + copySafePoint.toString());
 }

这次代码按预期运行，因为读和写在同一锁上同步，但是 我们删除了构造函数 。如果不允许这样做怎么办？

我们需要找到一种在同一锁上同步读取和写入SafePoint的方法。

理想情况下，我们想要这样的东西：

 public SafePoint(SafePoint safePoint){
     int [] xy = safePoint.getXY();
     this(xy[0], xy[1]);
 }

但是编译器不允许这样做。

我们可以通过调用* getXY 方法来安全地阅读，因此我们需要一种使用该方法的方法，但是我们没有这样的构造函数来接受此类参数-创建一个。

private SafePoint(int [] xy){
    this(xy[0], xy[1]);
}

然后，实际的调用：

public  SafePoint (SafePoint safePoint){
    this(safePoint.getXY());
}

请注意，该构造函数是私有的，这是因为我们不想公开另一个公共的构造函数，并 再次 考虑该类的不变量，因此我们将其设为私有-只有我们可以调用它。