Java static / non-static synchronized方法同时修改static成员变量，会有问题吗？

Question

Java里static和non-static synchronized方法锁住的分别是对象和类，因而是可以同时执行的，那么会存在修改问题吗？搜索没有得到比较关联的答案，来这里问问大家：

示例代码如下：

public class Test {
    
    private static int staticVariableOne = 0;
    
    public synchronized void nonStaticFunction() {
        // do some works
        staticVariableOne++;
        // do some works
    }
 
    public synchronized static void staticFunction() {
        // do some works
        staticVariableOne++;
        // do some works
    }

}

以上，两个线程分别同时调用nonStaticFunction()和staticFunction()，会出现这种情况（导致一次修改丢失）吗：

1. nonStaticFunction 读 staticVariableOne = 0
2. nonStaticFunction 阻塞
3. staticFunction 读 staticVariableOne = 0
4. staticFunction 写 staticVariableOne = 1
5. nonStaticFunction 继续
6. staticFunction 写 staticVariableOne = 1

Answer 1

参考StackOverflow问题：

http://stackoverflow.com/ques...

但是，还是意犹未尽，还请各位多多指教、探讨！

---

补充：

运行如下测试程序，最后的结果并不是20000，中间有很多次结果都被覆盖了。

public class Test {
    
    private static int staticVariableOne = 0;

    public Test() {
        super();
    }
    
    public static int getStaticVariableOne() {
        return staticVariableOne;
    }

    public static void setStaticVariableOne(int staticVariableOne) {
        Test.staticVariableOne = staticVariableOne;
    }
    
    private static void increaseStaticVariableOne() {
        staticVariableOne++;
    }
    
    public synchronized void add() {
        System.out.println("执行 add() 开始...");
        try {
            for (int i  = 0; i < 10000; i++) {
                increaseStaticVariableOne();
                Thread.sleep(1);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行 add() 完毕...");
    }
 
    public synchronized static void addStatic() {
        System.out.println("执行 addStatic() 开始...");
        try {
            for (int i  = 0; i < 10000; i++) {
                increaseStaticVariableOne();
                Thread.sleep(2);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行 addStatic() 完毕...");
    }

}

public class StudyMain {
    public static void main( String[] args ) {
        
        final Test insertData = new Test();
        Thread threadOne = new Thread() {
            @Override
            public void run() {
                insertData.add();
            }
        };
        
        Thread threadTwo = new Thread() {
            @Override
            public void run() {
                Test.addStatic();
            }
        };
        
        threadOne.start();
        threadTwo.start();
        try {
            threadOne.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            threadTwo.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("After 20000 times increasements, final staticVariableOne is "
        + Test.getStaticVariableOne());
    }
}

Answer 2

不清楚你的困惑在哪里……static和non-static synchronized方法锁住的分别是对象和类的实例，锁的作用对象都不同。你分别通过threadOne调用add()方法，threadTwo调用addStatic()方法，两个线程同时对一个线程不安全的共享变量进行值的修改，肯定要注意并发问题。要解决你的问题的话，有两个方案：
(1)定义一个私有构造函数，禁止类被实例化，让所有的操作都通过Test.addStatic()方法去执行；
(2)使用线程安全的方式来申明变量staticVariableOne。