这里已经有很多答案，但我真的很想深入了解一些细节（就我的知识而言，让我吧）。我强烈建议您运行答案中出现的每个示例，以亲自了解事情的发生方式和原因。
要了解解决方案，首先要了解问题。
假设 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。它们是否受到某种同步机制的保护？好吧，它们是通过内在锁，通过 synchronized 关键字 - 至少在 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}
这是逻辑，因为一个线程更新=写入我们的对象，另一个正在读取它。它们不会在某些公共锁上同步，因此不会同步输出。
解决方案？
同步构造器，这样读取将在同一个锁上同步，但是Java中的构造器不能使用同步关键字——这当然是逻辑。
-
可以使用不同的锁，比如可重入锁（如果同步关键字不能使用）。但它也不起作用，因为构造函数中的第一条语句必须是对 this/super 的调用。如果我们实现不同的锁，那么第一行必须是这样的：
lock.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());
}
注意构造函数是私有的，这是因为我们不想暴露另一个公共构造函数并再次考虑类的不变量，因此我们将其设为私有 - 只有我们可以调用它。