java中的不正确同步

因此，我试图学习java线程和同步。下面的代码没有正确同步，有人能解释一下原因吗

package threadPractice;

public class T2 extends Thread {
     public static int count=0;
     public T2( ) { }
     private synchronized void update( ) {
         int v = count;
         try {
             sleep(10);
         } catch (Exception e) { }
         v++;
         count = v;
     }
     public void run( ) {
     for (int i = 0; i < 1000; i++) {
     update( );
     }
     }
}

---

我的预期产量是2000年。我的实际输出介于0和2000之间。

因为您创建了两个不同的对象进行同步。如果您想要一个锁来保护一个字段（

count

），则需要使用一个锁。为每个线程提供自己的锁意味着任何线程都不知道其他线程何时实际使用该锁

首先，如果您的字段是公共的，则没有任何内容受到保护。保密

其次，在这种情况下，使用静态方法来保护静态字段

public class T2 extends Thread {
     private static int count=0;

     private static synchronized void update( ) {
         int v = count;
         try {
             sleep(10);
         } catch (Exception e) { }
         v++;
         count = v;
     }

     @Override
     public void run( ) {
       for (int i = 0; i < 1000; i++) {
       update( );
     }
     }
}

---

如果您不想使同步方法成为静态的（例如，因为您正在访问实例变量），可以在静态内部对象中持有锁。T2的所有不同实例都将使用相同的锁引用，如下所示：

public class T2 extends Thread {
    public static int count = 0;
    private final static Object LOCK = new Object(); // Static lock

    public T2() {
    }

    private void update() {
        synchronized (LOCK) { // Every instance of T2 uses the same lock
            int v = count;
            try {
                sleep(10);
            } catch (Exception e) {
            }
            v++;
            count = v;
        }
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            update();
        }
    }
}

public类T2扩展线程{
公共静态整数计数=0；
私有最终静态对象锁=新对象（）；//静态锁
公共T2（）{
}
私有void更新（）{
synchronized（LOCK）{//T2的每个实例都使用相同的锁
int v=计数；
试一试{
睡眠（10）；
}捕获（例外e）{
}
v++；
计数=v；
}
}
公开募捐{
对于（int i=0；i<1000；i++）{
更新（）；
}
}
}

以下代码未正确同步是什么意思？能否将实际输出和预期输出放在一起。

public class T2 extends Thread {
     private static final AtomicInteger count = new AtomicInteger();

     @Override
     public void run( ) {
       for (int i = 0; i < 1000; i++) {
         count.incrementAndGet();
       }
     }
}

public class T2 extends Thread {
    public static int count = 0;
    private final static Object LOCK = new Object(); // Static lock

    public T2() {
    }

    private void update() {
        synchronized (LOCK) { // Every instance of T2 uses the same lock
            int v = count;
            try {
                sleep(10);
            } catch (Exception e) {
            }
            v++;
            count = v;
        }
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            update();
        }
    }
}