多线程下的函数调用次数统计，帮助理解synchronized和static关键字

统计函数调用次数：

import java.lang.Thread;

public class CalculateCallTime implements Runnable {
    private static int times = 0;

    private static Object mem = new Object();

    /**
     * 方法1：
     */
    public static synchronized void foo() {
        times++;
        System.out.println(times);
    }

    /**
     * 方法2：
     */
    public void foo() {
        synchronized(mem) {
            times++;
            System.out.println(times);
        }
    }

    /**
     * 方法3：
     * 输出结果为  begin begin begin 4 4 4 
     * 说明 static 修饰的函数可被多个对象同时访问
     */
    public synchronized void foo() {
        times++;
        System.out.println("begin");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(times);
    }

    public static void main(String args[]) {
        Thread thread1 = new Thread(new CalculateCallTime());
        Thread thread2 = new Thread(new CalculateCallTime());
        Thread thread3 = new Thread(new CalculateCallTime());

        thread1.start();
        thread2.start();
        thread3.start();
    }

    @Override
    public void run() {
        this.foo();
    }
}

如上，多线程环境下，方法1、方法2的执行不会有问题；
但是方法3会有问题，即输出的结果具有不确定性；

public static void main(String args[]) {
        CalculateCallTime a = new CalculateCallTime();
        Thread thread1 = new Thread(a);
        Thread thread2 = new Thread(a);
        Thread thread3 = new Thread(a);

        thread1.start();
        thread2.start();
        thread3.start();
    }

如果main函数中的调用这样修改，则不会出现线程同步问题，原因：
synchronized为对象同步锁，多线程下，调用foo()函数时，锁住对象a，使得thread2和thread3无法获取当前对象a，因此无法访问函数foo()，即不会出现多线程的同步问题；