synchronized关键字理解

synchronized是对象锁，也就是多线程操作某一个对象时对该对象的所有同步资源进行锁定。

// class MyObject 
public class MyObject {

    synchronized public void methodA() {
        try{
            System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end methodA, endTime=" + System.currentTimeMillis());
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        try{
            System.out.println("begin methodB threadName=" + Thread.currentThread().getName()
                    + " begin time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end methodB, endTime=" + System.currentTimeMillis());
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}
// class ThreadA
public class ThreadA extends Thread {
    private MyObject object;

    public ThreadA(MyObject object) {
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}
// class ThreadB
public class ThreadB extends Thread {
    private MyObject object;

    public ThreadB(MyObject object) {
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodB();
    }

}
// main class
public static void main(String[] args) {
    myObject();
}

private static void myObject() {
    MyObject object = new MyObject();
    ThreadA threadA = new ThreadA(object);
    threadA.setName("A");
    ThreadB threadB = new ThreadB(object);
    threadB.setName("B");
    threadA.start();
    threadB.start();
}

输出结果：

begin methodA threadName=A
begin methodB threadName=B begin time=1496543751228
end methodA, endTime=1496543756228
end methodB, endTime=1496543756228

从上面的结果可以看出，线程A和线程B在调用MyObject 类的同一个对象的不同方法是异步的，线程A调用methodA是所属临界资源，需要加同步锁，但是线程B调用的methodB并不属于临界资源，即使线程A获得了对象的锁也不影响线程B调用非临界资源methodB。

我们将MyObject的methodB也加上synchronized关键字，将该方法修改为临界资源。如下所示：

public class MyObject {

    synchronized public void methodA() {
        try{
            System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end methodA, endTime=" + System.currentTimeMillis());
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void methodB() {
        try{
            System.out.println("begin methodB threadName=" + Thread.currentThread().getName()
                    + " begin time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end methodB, endTime=" + System.currentTimeMillis());
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

其他代码不变，再运行一下结果如下：

begin methodA threadName=A
end methodA, endTime=1496543732497
begin methodB threadName=B begin time=1496543732497
end methodB, endTime=1496543737498

从以上输出结果可以看出，在线程A执行methodA时，线程B是在等待状态的，必须等线程A执行完methodA后释放了对象锁，然后线程B才可以执行methodB方法。

在线程A执行methodA时，线程A获得了MyObject类的对象object的锁，也就是object的所有被synchronized关键字修饰的变量和方法都只能被线程A所使用，其他线程必须等待线程A使用完成后释放对象锁后才能去获取object对象的锁，然后去执行object对象的方法。

结论：
1) A线程先持有object对象的lock锁，B线程可以以异步的方式调用object对象中的非synchronized类型的方法。

2) A线程先持有object对象的lock锁，B线程如果在这时调用object对象中的synchronized类型的方法则需要等待，也就是同步。