Java中synchronized同步的理解

在并发访问的问题上，Java引入了同步监视器来应对，主要是通过关键字synchronized实现。关于synchronized，它有两种形式，一种是同步代码块：synchronized(obj){},另一种是同步方法：public synchronized void method1(){}，前者比较灵活，可以自己控制同步的范围，而后者同步的是整个方法。

同步代码块

synchronized(obj){}

在上述代码中，对象obj即是同步监视器，代码表示，如果要执行{}中的代码，必须先获得对obj的锁定。该对象可以是任何对象，但是一般情况下推荐使用那个要被并发访问的对象，因为同步监视器的作用就是防止对某资源进行并发访问。比如

package com.hm.thread.test;

public class Thread111 implements Runnable {
    public Object o = new Object();
    public void run() {
        synchronized (o) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
            }
        }
    }

    public static void main(String[] args) {
        Thread111 t1 = new Thread111();
        Thread ta = new Thread(t1, "A");
        Thread tb = new Thread(t1, "B");
        ta.start();
        tb.start();
    }
}

如果不加synchronized (o) {},则输出的A,B是交错的，因为两个线程A,B并发执行，所以打印的结果就是交替输出。而使用了synchronized (o) {}之后，两个线程都要去获取o的锁，那么就变成了同步执行了，A和B分别输出：

A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

 同步方法

public synchronized void method1(){}

对于同步方法来说，没有显式的指定同步监视器，实际的同步监视器是this，即调用该方法的对象本身。

这里有一点需要注意：是否是同一个对象在多线程的访问同步方法。

这里借用一些例子说明，比如：

package com.hm.thread.account;

class Account {
    String name;
    float amount;

    public Account(String name, float amount) {
        this.name = name;
        this.amount = amount;
    }

    public synchronized void deposit(float amt) {
        float tmp = amount;
        tmp += amt;
        try {
            Thread.sleep(1);// 模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) { }
        amount = tmp;
    }

    public synchronized void withdraw(float amt) {
        float tmp = amount;
        tmp -= amt;
        try {
            Thread.sleep(114);// 模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) { }
        amount = tmp;
    }

    public float getBalance() {
        return amount;
    }
}

public class AccountTest {
    private static int NUM_OF_THREAD = 200;
    static Thread[] threads = new Thread[NUM_OF_THREAD];

    public static void main(String[] args) {
        final Account acc = new Account("John", 1000.0f);
        for (int i = 0; i < NUM_OF_THREAD; i++) {
            threads[i] = new Thread(new Runnable() {
                public void run() {
                    acc.deposit(100.0f);
                    acc.withdraw(100.0f);
                }
            });
            threads[i].start();
        }

        for (int i = 0; i < NUM_OF_THREAD; i++) {
            try {
                threads[i].join(); // 等待所有线程运行结束
            } catch (InterruptedException e) {
            }
        }
        System.out.println("Finally, John's balance is:" + acc.getBalance());
    }

}

在上面的例子中，模拟账户中有1000元，存取款各100元，各200次，理论上余额应该还是1000，但是对于deposite()和 withdraw()方法，如果去掉synchronized修饰，则结果是不确定的。加上synchronized，则对于同一个account对象，在多个线程中并发访问deposite()和withdraw()方法，这两个方法都变成同步的了，即多个线程被同步了。

那么换个例子

package com.hm.thread.test;

public class ClassSync_Test {
    public static void main(String[] args) {
        Foo f1 = new Foo(1);
        Foo f2 = new Foo(3);
        f1.start();
        f2.start();
    }
}

class Foo extends Thread {
    private int val;
    public Foo(int val){
        this.val = val;
    }
    
    public synchronized void print(int v){
            int n = 100;
            int i = 0;
            while(i < n){
                System.out.println(v);
                i++;
                try {
                    Thread.currentThread().sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
    public void run(){
        print(val);
    }
}

在这个例子中，print()也是同步方法，但是在main方法中new出了两个Foo对象，分别启动线程执行，可以看到1和3交替出现，说明这个方法同时被两个线程执行了，而并不是同步的，原因在哪？

在Java中，类本身只有一个实例，但是类产生的对象却可以多个。对于Foo，它存在两个实例对象，启动它们的线程，彼此并不干扰，所以它们各自执行自己的同步方法。换句话说，synchronized虽然锁住了这个方法，但是只是针对同一个对象来说的，不同的对象会获取了各自的锁，彼此没有影响。所以，如果要实现同步，则需要让不同的对象在访问这个方法的时仍然去获取同一把锁，而不是各自获取各自的。即让synchronized去同步一个类级别的对象。

可以这么修改print()：

public void print(int v){
        synchronized(Foo.class){
            int n = 100;
            int i = 0;
            while(i < n){
                System.out.println(v);
                i++;
                try {
                    Thread.currentThread().sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

当锁住Foo.class之后，该类对应的对象在访问print方法时都会去获取Foo.class身上的锁--同一把锁。所以实现了同步。或者可以在该类中创建一个全局的静态变量，然后替换掉Foo.class也是可以的，因为静态的变量和类一样，都只有一份（要注意锁住一个class，范围较大，性能不好）。

另外一方面，对于wait(),notify(),notifyAll()三个方法，它们属于Object类，并且必须由同步监视器调用。所以在同步代码块中，使用obj去调用,obj.wait()。而对于同步方法来说，由于它没有显示指定同步监视器，并且监视器就是this，所以可以直接调用：this.wait()或者wait()。

引用：

http://www.shangxueba.com/jingyan/90315.html

http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html#top