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() {
	}
	//对方法加锁，同步，class
	private 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.如果修饰的是非静态，则锁是对对象，如果是静态或者类，类的所有对象是同一把锁