synchronized关键字的语义

上一篇文章，我们讲到，如果发生了多个线程共同访问一个全局变量的时候，就会发生各种意料之外的情况。其实现实生活中有很多这样的例子。我举一个例子。

一群人都要过河，但是河面上只有一只独木舟，除了船夫，一次只能带一个人。所有到达河边的人都想往船上抢，难免把船搞翻了。为了解决这个问题，我们可以在河边上设一个售票处，谁先抢到票，谁就可以上船，没有抢到票的，就只能等待下一次，船返回来，再去抢下一张票。

好了，在多线程编程中，我们也可以引入这样一个售票处，让线程先去抢票，抢到票的，就可以使用这只小船，抢不到的，就继续等待。这个售票处，就是 synchronized 了。

synchronized 方法

当一个方法加上synchronized 关键字以后，就只能让一个线程来执行这个方法了。只让一个线程的意思并不是只把这个方法指定给某个固定的线程，而是说一次只能有一个线程来调用这个函数。

我们把昨天的那个程序改一下，就很清楚了：

public class TestTwo {
    public int total = 0;

    public synchronized void incTotal() {
        total += 1;
    }

    public static void main(String[] args) throws Exception{
        TestTwo test = new TestTwo();

        Thread t1 = new Thread() {
            public void run() {
                for (int i = 0; i < 5_000; i++) {
                    test.incTotal();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                for (int i = 0; i < 5_000; i++) {
                    test.incTotal();
                }
            }
        };

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(test.total);
    }
}

现在不论你执行多少次，最后的结果一定会是10000了，这是因为我们把加1的操作用synchronized 保护起来了。一旦一个线程进入到了 incTotal 以后，其他的线程就不能再进入了。这样，我们就可以保证这个加法是完整而且独立的，其他的线程完全不能打扰到它了。

synchronized block

有时候，我们使用synchronized 修饰一个方法，会显得太重了一些。往往需要使用这种互斥进行保护的只是几个语句，而不是一个方法。那我们还可以使用语句块，它的语法是这样的：

synchronized(object) {
    // do something
}

例如，上面的例子，我们还可以这样写：

public class TestThree {
    public int total = 0;

    public static void main(String[] args) throws Exception{
        TestThree test = new TestThree();

        Thread t1 = new Thread() {
            public void run() {
                for (int i = 0; i < 5_000; i++) {
                    synchronized (test) {
                        test.total += 1;
                    }
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                for (int i = 0; i < 5_000; i++) {
                    synchronized (test) {
                        test.total += 1;
                    }
                }
            }
        };

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(test.total);
    }
}

看，我们在这里就不用再定义一个synchronized方法了。而是在一个对象上加上这个互斥就可以了。

实际上，这里都不定要使用 test 这个对象。例如，我可以用一个完全不相干的对象来做互斥：

Object o = new Object();
synchronized(o) {
   do_something...
}

只要这个变量是两个线程都能访问就可以了。