在java多线程并发编程中对于 sychronized 大家一定不陌生，同步关键字 synchronized 是java语言中最为常用的同福方法之一。那什么情况下才用到 sychronized 呢？怎么用呢
当有多个线程同时对一个变量进行读写的时候就可能出现数据不一致的现象，这时候就需要同步，限制为排队一个个来。就好比你去买水果，称水果的时候如果与别人共用以个袋子，你自己到底买了多少水果你根本不会知道。这时候就是 sychronized 上场的时候了。简单说 sychronized 就是为了保证数据安全的。
sychronized 一般用来修饰一个方法或者一个代码块。利用sychronized实现同步的基础：java中每一个对象都可以作为锁。具体表现为以下3中形式。
1.对于普通方法的同步，锁是当前实例对象。
2.对于静态方法的同步，锁是当前类的Class对象。
3.对于同步方法块，锁是sychronized括号里配置的对象。
下面用代码来演示一遍。
一、用sychronized修饰一个方法的时候
1.sychronized修饰普通方法
public class ThreadTest extends Thread{
private Test test;
public ThreadTest(String name,Test test) {
super(name);
this.test = test;
}
@Override
public void run() {
test.method();
}
}
public class Test{
public static void main(String[] args) {
Test test1 = new Test();
Test test2 = new Test();
ThreadTest thread1 = new ThreadTest("线程1", test1);
ThreadTest thread2 = new ThreadTest("线程2", test1); //(1)
// ThreadTest thread2 = new ThreadTest("线程2", test2); //(2)
thread1.start();
thread2.start();
}
public synchronized void method(){
System.out.println(Thread.currentThread().getName()+" 获得锁");
try {
System.out.println("开始方法......");
Thread.sleep(2000); //模拟做其他事情
System.out.println("结束方法......");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
上面程序执行的结果是：
线程1 获得锁
开始方法......
结束方法......
线程2 获得锁
开始方法......
结束方法......
当把代码（1）注释掉，打开代码（2），执行结果是：
线程1 获得锁
线程2 获得锁
开始方法......
开始方法......
结束方法......
结束方法......
结果分析：
从结果（1）可以看出，是同一实例对象的时候，多线程同一时刻只能有一个线程能获得锁，其他线程必须等锁释放了才能获取。
从结果（2）可以看出，当不是同一个实例对象的时候，线程获得的锁与其他线程无关，不需等待其他线程的锁释放。
综合得出：sychronized修饰普通方法的时候，锁是当前实例对象，每个实例对象一把锁，同一时刻只能一个线程获得锁。不同实例对象获取的锁不一样，不需等待其他实例对象锁的释放。
2.sychronized修饰静态方法
public synchronized static void method(){
System.out.println(Thread.currentThread().getName()+" 获得锁");
try {
System.out.println("开始方法......");
Thread.sleep(2000); //模拟做其他事情
System.out.println("结束方法......");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
当把method()改为静态的时候。按照上面的执行方法，执行结果都是
线程1 获得锁
开始方法......
结束方法......
线程2 获得锁
开始方法......
结束方法......
从结果可以得出：sychronized修饰静态方法的时候，锁是当前类的Class对象，每个类对应一把锁，多线程不同实例对象同一时刻也只能是一个获得锁，其他必须等待锁的释放。
二、用sychronized修饰代码块的时候
1.sychronized（object）括号配置的是普通变量的时候
public class Test{
private Object object = new Object();
public static void main(String[] args) {
Test test1 = new Test();
Test test2 = new Test();
ThreadTest thread1 = new ThreadTest("线程1", test1);
ThreadTest thread2 = new ThreadTest("线程2", test1); //(1)
// ThreadTest thread2 = new ThreadTest("线程2", test2); //(2)
thread1.start();
thread2.start();
}
public void method(){
synchronized (object) {
System.out.println(Thread.currentThread().getName()+" 获得锁");
try {
System.out.println("开始方法......");
Thread.sleep(2000); //模拟做其他事情
System.out.println("结束方法......");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
上面程序执行的结果是：
线程1 获得锁
开始方法......
结束方法......
线程2 获得锁
开始方法......
结束方法......
当把代码（1）注释掉，打开代码（2），执行结果是：
线程1 获得锁
线程2 获得锁
开始方法......
开始方法......
结束方法......
结束方法......
结果分析：
从结果（1）可以看出，是同一实例对象的时候(变量object一样)，多线程同一时刻只能有一个线程能获得锁，其他线程必须等锁释放了才能获取。
从结果（2）可以看出，当不是同一个实例对象的时候(变量object不一样)，线程获得的锁与其他线程无关，不需等待其他线程的锁释放。
综合得出：sychronized（object）{} object为普通变量的时候，每个实例对象一把锁，同一时刻只能一个线程获得锁。不同实例对象获取的锁不一样，不需等待其他实例对象锁的释放。
2.sychronized（object）括号配置的是静态变量的时候
private static Object object = new Object();
当把object变量改为静态的时候（所有实例对象的object都一样），执行结果都是如下：
线程1 获得锁
开始方法......
结束方法......
线程2 获得锁
开始方法......
结束方法......
结果分析：sychronized（object）{} object为静态变量的时候，锁是当前类的Class对象，每个类对应一把锁，多线程不同实例对象同一时刻也只能是一个获得锁，其他必须等待锁的释放。
3.sychronized（object）括号配置的是类Class的时候
public void method(){
synchronized (Test.class) {
System.out.println(Thread.currentThread().getName()+" 获得锁");
try {
System.out.println("开始方法......");
Thread.sleep(2000); //模拟做其他事情
System.out.println("结束方法......");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
当sychronized（object）括号配置的是类Class的时候 执行结果都是如下：
线程1 获得锁
开始方法......
结束方法......
线程2 获得锁
开始方法......
结束方法......
结果分析：sychronized（object）{} object为类Class的时候，锁是当前类的Class对象，每个类对应一把锁，多线程不同实例对象同一时刻也只能是一个获得锁，其他必须等待锁的释放。
总结：
A、A. 无论synchronized关键字是修饰在方法上还是代码块，如果它作用的对象是非静态的，则它取得的锁是对象，每个实例对象一把锁；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
在用synchronized修饰方法时要注意以下几点：
- synchronized关键字不能继承。
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
在子类方法中加上synchronized关键字
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}
在子类方法中调用父类的同步方法
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public void method() { super.method(); }
}
在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
