这里已经有很多答案了，但我真的很想深入了解一些细节（据我所知，让我来吧）。我强烈建议您运行答案中存在的每个示例，以亲自了解事情的发生方式和原因。
要了解解决方案，您需要先了解问题。
假设 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}
这是逻辑，因为一个线程更新=写入我们的对象，而另一个线程正在读取它。它们不会在某些通用锁上同步，因此不会同步输出。
解决方案？
synchronized 构造函数，这样读取将在同一个锁上同步，但是 Java 中的构造函数不能使用 synchronized 关键字——这当然是逻辑。
可能会使用不同的锁，例如可重入锁（如果无法使用同步关键字）。但它也不起作用，因为构造函数中的第一条语句必须是对 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());
}
请注意，构造函数是私有的，这是因为我们不想再暴露另一个公共构造函数并重新考虑类的不变量，因此我们将其设为私有 - 只有我们可以调用它。