synchronized用法

synchronized是Java中的关键字，是一种同步锁。

四种用法：

1，修饰一个代码块

当synchronized修饰代码块的时候，表示线程在执行的时候会将synchronized括号中的对象上锁，这个对象可以是任意类的对象，也可以使用this关键字。作用的范围是大括号{}括起来的代码，一个线程访问一个对象中的synchronized(变量)同步代码块时，其他试图访问该对象的线程将被阻塞,一次只有一个线程进入该对象代码块。同步锁作用的对象是调用这个代码块的对象，每个对象只有一把锁与之关联，不同对象的锁互不干扰不形成互斥。

1.1，当synchronized（this）thisi指的是执行这段代码的对象

测试示例：

网上源代码修改：

public class Counter implements Runnable {private int count;public Counter() {count = 0;}public void countAdd() {synchronized (this) {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + (count++));Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}public void printCount() {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + " count:" + count);Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}public void run() {String threadName = Thread.currentThread().getName();if (threadName.equals("A")) {countAdd();} else if (threadName.equals("B")) {printCount();} else if (threadName.equals("A_1")) {countAdd();}}}

测试用例：

public static void main(String args[]) {Counter counter = new Counter();// 测试单个对象的多线程访问同步代码块Thread thread1 = new Thread(counter, "A");Thread thread2 = new Thread(counter, "A_1");thread1.start();thread2.start();                //结果：A:0 A:1 A:2 A:3 A:4 A_1:5 A_1:6 A_1:7 A_1:8 A_1:9               // 测试多个个对象的多线程访问同步代码块Thread thread1_1 = new Thread(new Counter(), "A");Thread thread2_1 = new Thread(new Counter(), "A_1");thread1_1.start();thread2_1.start();                //结果：A:0 A_1:0 A_1:1 A:1 A:2 A_1:2 A:3 A_1:3 A_1:4 A:4               // 测试多线程访问非同步代码块Thread thread3 = new Thread(counter, "A");Thread thread4 = new Thread(counter, "B");thread3.start();thread4.start();                //结果：A:0 B count:1 B count:1 A:1 A:2 B count:2 B count:3 A:3 A:4 B count:5 }

结论：synchronized关键字锁定的是对象，对于代码块的修饰，同一个对象的多线程互斥的访问同步语句块互斥，同一对象的非synchronized代码段可以并行访问，不同对象每个对象对synchronized修饰的语句块有独立的锁，不同对象的线程可以并行访问synchronized同步代码块。

1.2当synchronized（i）i是对象时，结论合上述一致，不过在单例模式情况下只对对象修饰会出问题，因为java指令中创建对象和赋值操作是分开的，JVM并不会保证顺序，多线程访问时有可能一个线程进入同步对象快块后，JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，并未实例化就放弃了锁，导致另一个线程判断出instance不为空操作这个为实例化的实例抛出异常
例子：

public class Singleton {    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */    private static Singleton instance = null;    /* 私有构造方法，防止被实例化 */    private Singleton() {    }    /* 静态工程方法，创建实例 */    public static Singleton getInstance() {        if (instance == null) {            //对对象加锁，会导致多线程问题            synchronized (instance) {                if (instance == null) {                    instance = new Singleton();                }            }        }        return instance;    }}  

这种情况下，最好是将 instance = new Singleton();  放到方法，用synchronized修饰方法打到对象的完全实例化。

public class SingletonTest {private static SingletonTest instance = null;private SingletonTest() {}//对方法加锁，同步，classprivate static synchronized void syncInit() {if (instance == null) {instance = new SingletonTest();}}public static SingletonTest getInstance() {if (instance == null) {syncInit();}return instance;}}

1.3 A.class得到的是A类，所以synchronized关键字得到的锁是类的锁，所有需要类的锁的方法等不能同时执行，等同于修饰静态方法

synchronized（A.class）{    //互斥代码}

2.，修饰一个方法

在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数，另外，synchronized关键字不可以被继承，子类需要新加或者用super.method()实现，在定义接口方法时不能使用synchronized关键字，构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

public void method() { super.method();

写法：

public synchronized void method(){   // todo}

或者

public void method(){   synchronized(this) {      // todo   }}

3，修饰一个静态方法

静态方法属于类而不属于对象，synchronized修饰静态方法锁定的是这个类的所有对象，被锁定类的所有对象使用的是同一把锁。
网上源码例子：

class SyncThread implements Runnable {   private static int count;   public SyncThread() {      count = 0;   }   public synchronized static void method() {      for (int i = 0; i < 5; i ++) {         try {            System.out.println(Thread.currentThread().getName() + ":" + (count++));            Thread.sleep(100);         } catch (InterruptedException e) {            e.printStackTrace();         }      }   }   public synchronized void run() {      method();   }}

测试用例：

//同一个类的两个对象实例Thread thread1 = new Thread(new syncThread（）, "SyncThread1");Thread thread2 = new Thread(new syncThread（）, "SyncThread2");thread1.start();thread2.start();

结果：

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

解释：对于run方法两个不同对象的线程可以并行访问，对于method方法，一但某个对象的一个线程进入方法，另一个对像就要等待，静态方法的关键字是锁定了这个类的所有对象。

4，修饰一个类

synchronized作用于一个类时，给这个类加锁，类的所有对象用的是同一把锁。用法：

class ClassName {   public void method() {      synchronized(ClassName.class) {      }   }}

效果跟修饰静态方法一致

总结：

1.锁是针对对象来讲的，每个对象只有一个锁关联，谁控制了锁谁就可以执行，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。

2.如果修饰的是非静态，则锁是对对象，如果是静态或者类，类的所有对象是同一把锁