synchronize——对象锁和类锁

最近在研究Java 多线程的只是，经常能看到synchronize关键字，以前只是一眼带过，没有细究，今天趁这个机会，整理下

synchronize作为多线程关键字，是一种同步锁，它可以修饰以下几种对象：

代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号{ }里的代码，作用的对象是调用这个代码块的对象；

方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象

静态方法：作用的范围是整个静态方法，作用的对象是这个类的所有对象

类：作用的范围是synchronize后面括号里的部分，作用的对象是这个类的所有对象

一、synchronize关键字

1.修饰方法

 synchronized public void getValue() {
     System.out.println("getValue method thread name="
             + Thread.currentThread().getName() + " username=" + username
             + " password=" + password);
 }

2.修饰代码块

 public void serviceMethod() {
     try {
         synchronized (this) {
             System.out.println("begin time=" + System.currentTimeMillis());
             Thread.sleep(2000);
             System.out.println("end    end=" + System.currentTimeMillis());
         }
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }

3.修饰类

 public static void printA() {
         synchronized (Service.class) {
             try {
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "进入printA");
                 Thread.sleep(3000);
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "离开printA");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

     }

二、Java中的对象锁和类锁

借用网友对对象锁和类锁定义

 一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，
 在Java里边就是拿到某个同步对象的锁（一个对象只有一把锁）；
 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。
 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；
 线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。
 这样就保证了同步代码在统一时刻只有一个线程在执行。

三、synchronize的用法与实例

总结：

synchronize修饰非静态方法、同步代码块的synchronize(this)和synchronize(非this对象)的用法锁的是对象，线程想要执行对应的同步代码，需要获得对象锁。

synchronize修饰静态方法以及同步代码块的synchronize(类.class)用法锁是类，线程想要执行对应的同步代码，需要获得类锁。

1.首先看下非线程安全例子

 public class Run {

     public static void main(String[] args) {

         HasSelfPrivateNum numRef = new HasSelfPrivateNum();

         ThreadA athread = new ThreadA(numRef);
         athread.start();

         ThreadB bthread = new ThreadB(numRef);
         bthread.start();

     }

 }

 class HasSelfPrivateNum {

     private int num = 0;

     public void addI(String username) {
         try {
             if (username.equals("a")) {
                 num = 100;
                 System.out.println("a set over!");
                 Thread.sleep(2000);
             } else {
                 num = 200;
                 System.out.println("b set over!");
             }
             System.out.println(username + " num=" + num);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

 }

 class ThreadA extends Thread {

     private HasSelfPrivateNum numRef;

     public ThreadA(HasSelfPrivateNum numRef) {
         super();
         this.numRef = numRef;
     }

     @Override
     public void run() {
         super.run();
         numRef.addI("a");
     }

 }

  class ThreadB extends Thread {

     private HasSelfPrivateNum numRef;

     public ThreadB(HasSelfPrivateNum numRef) {
         super();
         this.numRef = numRef;
     }

     @Override
     public void run() {
         super.run();
         numRef.addI("b");
     }

 }

运行结果：

 a set over!
 b set over!
 b num=200
 a num=200

修改HasSelfPrivateNum如下，方法用synchronize修饰如下：

 class HasSelfPrivateNum {

     private int num = 0;

     synchronized public void addI(String username) {
         try {
             if (username.equals("a")) {
                 num = 100;
                 System.out.println("a set over!");
                 Thread.sleep(2000);
             } else {
                 num = 200;
                 System.out.println("b set over!");
             }
             System.out.println(username + " num=" + num);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

 }

运行结果是线程安全的：

 b set over!
 b num=200
 a set over!
 a num=100

由于sleep方法不会放弃对象锁，需要等到时间结束，释放锁，下一个进程才能获取到该对象锁

实验结论：两个线程访问同一个对象中的同步方法是一定是线程安全的。本实现由于是同步访问，所以先打印出a，然后打印出b。

这里线程获取的是HasSelfPrivateNum的对象实例的锁——对象锁。

2.多个对象多个锁

 public class Run {

     public static void main(String[] args) {

         HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
         HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

         ThreadA athread = new ThreadA(numRef1);
         athread.start();

         ThreadB bthread = new ThreadB(numRef2);
         bthread.start();

     }

 }

运行结果：

 a set over!
 b set over!
 b num=200
 a num=200

这里是非同步的，因为线程athread获得是numRef1的对象锁，而bthread线程获取的是numRef2的对象锁，他们并没有在获取锁上有竞争关系，因此，出现非同步的结果。

3.同步块synchronize(this)

 public class Run {

     public static void main(String[] args) {
         ObjectService service = new ObjectService();

         ThreadA a = new ThreadA(service);
         a.setName("a");
         a.start();

         ThreadB b = new ThreadB(service);
         b.setName("b");
         b.start();
     }

 }

 class ObjectService {

     public void serviceMethod() {
         try {
             synchronized (this) {
                 System.out.println("begin time=" + System.currentTimeMillis());
                 Thread.sleep(2000);
                 System.out.println("end    end=" + System.currentTimeMillis());
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

 class ThreadA extends Thread {

     private ObjectService service;

     public ThreadA(ObjectService service) {
         super();
         this.service = service;
     }

     @Override
     public void run() {
         super.run();
         service.serviceMethod();
     }

 }

 class ThreadB extends Thread {
     private ObjectService service;

     public ThreadB(ObjectService service) {
         super();
         this.service = service;
     }

     @Override
     public void run() {
         super.run();
         service.serviceMethod();
     }
 }

运行结果：

 begin time=1466148260341
 end    end=1466148262342
 begin time=1466148262342
 end    end=1466148264378

这样也是同步的，线程获取的是同步块synchronized (this)括号（）里面的对象实例的对象锁，这里就是ObjectService实例对象的对象锁了。

4.synchronize(非this对象)

 public class Run {

     public static void main(String[] args) {

         Service service = new Service("xiaobaoge");

         ThreadA a = new ThreadA(service);
         a.setName("A");
         a.start();

         ThreadB b = new ThreadB(service);
         b.setName("B");
         b.start();

     }

 }

 class Service {

     String anyString = new String();

     public Service(String anyString){
         this.anyString = anyString;
     }

     public void setUsernamePassword(String username, String password) {
         try {
             synchronized (anyString) {
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "进入同步块");
                 Thread.sleep(3000);
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "离开同步块");
             }
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

 }

 class ThreadA extends Thread {
     private Service service;

     public ThreadA(Service service) {
         super();
         this.service = service;
     }

     @Override
     public void run() {
         service.setUsernamePassword("a", "aa");

     }

 }

 class ThreadB extends Thread {

     private Service service;

     public ThreadB(Service service) {
         super();
         this.service = service;
     }

     @Override
     public void run() {
         service.setUsernamePassword("b", "bb");

     }

 }

不难看出，这里线程争夺的是anyString的对象锁，两个线程有竞争同一对象锁的关系，出现同步。

5.静态synchronize同步方法

 public class Run {

     public static void main(String[] args) {

         ThreadA a = new ThreadA();
         a.setName("A");
         a.start();

         ThreadB b = new ThreadB();
         b.setName("B");
         b.start();

     }

 }

 class Service {

     synchronized public static void printA() {
         try {
             System.out.println("线程名称为：" + Thread.currentThread().getName()
                     + "在" + System.currentTimeMillis() + "进入printA");
             Thread.sleep(3000);
             System.out.println("线程名称为：" + Thread.currentThread().getName()
                     + "在" + System.currentTimeMillis() + "离开printA");
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     synchronized public static void printB() {
         System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                 + System.currentTimeMillis() + "进入printB");
         System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                 + System.currentTimeMillis() + "离开printB");
     }

 }

 class ThreadA extends Thread {
     @Override
     public void run() {
         Service.printA();
     }

 }

 class ThreadB extends Thread {
     @Override
     public void run() {
         Service.printB();
     }
 }

运行结果：

 线程名称为：A在1466149372909进入printA
 线程名称为：A在1466149375920离开printA
 线程名称为：B在1466149375920进入printB
 线程名称为：B在1466149375920离开printB

两个线程在争夺同一个类锁，因此同步。

6.synchronize(class)

 class Service {

     public static void printA() {
         synchronized (Service.class) {
             try {
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "进入printA");
                 Thread.sleep(3000);
                 System.out.println("线程名称为：" + Thread.currentThread().getName()
                         + "在" + System.currentTimeMillis() + "离开printA");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

     }

     public static void printB() {
         synchronized (Service.class) {
             System.out.println("线程名称为：" + Thread.currentThread().getName()
                     + "在" + System.currentTimeMillis() + "进入printB");
             System.out.println("线程名称为：" + Thread.currentThread().getName()
                     + "在" + System.currentTimeMillis() + "离开printB");
         }
     }
 }

运行结果：

 线程名称为：A在1466149372909进入printA
 线程名称为：A在1466149375920离开printA
 线程名称为：B在1466149375920进入printB
 线程名称为：B在1466149375920离开printB

两个线程依旧在争夺同一个类锁，因此同步。

总结：

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制