最近在研究Java 多线程的只是，经常能看到synchronize关键字，以前只是一眼带过，没有细究，今天趁这个机会，整理下
synchronize作为多线程关键字，是一种同步锁，它可以修饰以下几种对象：
代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号{ }里的代码，作用的对象是调用这个代码块的对象；
方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象
静态方法：作用的范围是整个静态方法，作用的对象是这个类的所有对象
类：作用的范围是synchronize后面括号里的部分，作用的对象是这个类的所有对象
一、synchronize关键字
1.修饰方法
1 synchronized public void getValue() { 2 System.out.println("getValue method thread name=" 3 + Thread.currentThread().getName() + " username=" + username 4 + " password=" + password); 5 }
2.修饰代码块
1 public void serviceMethod() { 2 try { 3 synchronized (this) { 4 System.out.println("begin time=" + System.currentTimeMillis()); 5 Thread.sleep(2000); 6 System.out.println("end end=" + System.currentTimeMillis()); 7 } 8 } catch (InterruptedException e) { 9 e.printStackTrace(); 10 } 11 }
3.修饰类
1 public static void printA() { 2 synchronized (Service.class) { 3 try { 4 System.out.println("线程名称为：" + Thread.currentThread().getName() 5 + "在" + System.currentTimeMillis() + "进入printA"); 6 Thread.sleep(3000); 7 System.out.println("线程名称为：" + Thread.currentThread().getName() 8 + "在" + System.currentTimeMillis() + "离开printA"); 9 } catch (InterruptedException e) { 10 e.printStackTrace(); 11 } 12 } 13 14 }
二、Java中的对象锁和类锁
借用网友对对象锁和类锁定义
1 一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限， 2 在Java里边就是拿到某个同步对象的锁（一个对象只有一把锁）； 3 如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。 4 取到锁后，他就开始执行同步代码(被synchronized修饰的代码）； 5 线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。 6 这样就保证了同步代码在统一时刻只有一个线程在执行。
三、synchronize的用法与实例
总结：
synchronize修饰非静态方法、同步代码块的synchronize(this)和synchronize(非this对象)的用法锁的是对象，线程想要执行对应的同步代码，需要获得对象锁。
synchronize修饰静态方法以及同步代码块的synchronize(类.class)用法锁是类，线程想要执行对应的同步代码，需要获得类锁。
1.首先看下非线程安全例子
1 public class Run { 2 3 public static void main(String[] args) { 4 5 HasSelfPrivateNum numRef = new HasSelfPrivateNum(); 6 7 ThreadA athread = new ThreadA(numRef); 8 athread.start(); 9 10 ThreadB bthread = new ThreadB(numRef); 11 bthread.start(); 12 13 } 14 15 } 16 17 class HasSelfPrivateNum { 18 19 private int num = 0; 20 21 public void addI(String username) { 22 try { 23 if (username.equals("a")) { 24 num = 100; 25 System.out.println("a set over!"); 26 Thread.sleep(2000); 27 } else { 28 num = 200; 29 System.out.println("b set over!"); 30 } 31 System.out.println(username + " num=" + num); 32 } catch (InterruptedException e) { 33 // TODO Auto-generated catch block 34 e.printStackTrace(); 35 } 36 } 37 38 } 39 40 41 class ThreadA extends Thread { 42 43 private HasSelfPrivateNum numRef; 44 45 public ThreadA(HasSelfPrivateNum numRef) { 46 super(); 47 this.numRef = numRef; 48 } 49 50 @Override 51 public void run() { 52 super.run(); 53 numRef.addI("a"); 54 } 55 56 } 57 58 59 60 class ThreadB extends Thread { 61 62 private HasSelfPrivateNum numRef; 63 64 public ThreadB(HasSelfPrivateNum numRef) { 65 super(); 66 this.numRef = numRef; 67 } 68 69 @Override 70 public void run() { 71 super.run(); 72 numRef.addI("b"); 73 } 74 75 }
运行结果：
1 a set over! 2 b set over! 3 b num=200 4 a num=200
修改HasSelfPrivateNum如下，方法用synchronize修饰如下：
1 class HasSelfPrivateNum { 2 3 private int num = 0; 4 5 synchronized public void addI(String username) { 6 try { 7 if (username.equals("a")) { 8 num = 100; 9 System.out.println("a set over!"); 10 Thread.sleep(2000); 11 } else { 12 num = 200; 13 System.out.println("b set over!"); 14 } 15 System.out.println(username + " num=" + num); 16 } catch (InterruptedException e) { 17 // TODO Auto-generated catch block 18 e.printStackTrace(); 19 } 20 } 21 22 }
运行结果是线程安全的：
1 b set over! 2 b num=200 3 a set over! 4 a num=100
由于sleep方法不会放弃对象锁，需要等到时间结束，释放锁，下一个进程才能获取到该对象锁
实验结论：两个线程访问同一个对象中的同步方法是一定是线程安全的。本实现由于是同步访问，所以先打印出a，然后打印出b。
这里线程获取的是HasSelfPrivateNum的对象实例的锁——对象锁。
2.多个对象多个锁
1 public class Run { 2 3 public static void main(String[] args) { 4 5 HasSelfPrivateNum numRef1 = new HasSelfPrivateNum(); 6 HasSelfPrivateNum numRef2 = new HasSelfPrivateNum(); 7 8 ThreadA athread = new ThreadA(numRef1); 9 athread.start(); 10 11 ThreadB bthread = new ThreadB(numRef2); 12 bthread.start(); 13 14 } 15 16 }
运行结果：
1 a set over! 2 b set over! 3 b num=200 4 a num=200
这里是非同步的，因为线程athread获得是numRef1的对象锁，而bthread线程获取的是numRef2的对象锁，他们并没有在获取锁上有竞争关系，因此，出现非同步的结果。
3.同步块synchronize(this)
1 public class Run { 2 3 public static void main(String[] args) { 4 ObjectService service = new ObjectService(); 5 6 ThreadA a = new ThreadA(service); 7 a.setName("a"); 8 a.start(); 9 10 ThreadB b = new ThreadB(service); 11 b.setName("b"); 12 b.start(); 13 } 14 15 } 16 17 class ObjectService { 18 19 public void serviceMethod() { 20 try { 21 synchronized (this) { 22 System.out.println("begin time=" + System.currentTimeMillis()); 23 Thread.sleep(2000); 24 System.out.println("end end=" + System.currentTimeMillis()); 25 } 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 } 30 } 31 32 33 class ThreadA extends Thread { 34 35 private ObjectService service; 36 37 public ThreadA(ObjectService service) { 38 super(); 39 this.service = service; 40 } 41 42 @Override 43 public void run() { 44 super.run(); 45 service.serviceMethod(); 46 } 47 48 } 49 50 51 class ThreadB extends Thread { 52 private ObjectService service; 53 54 public ThreadB(ObjectService service) { 55 super(); 56 this.service = service; 57 } 58 59 @Override 60 public void run() { 61 super.run(); 62 service.serviceMethod(); 63 } 64 }
运行结果：
1 begin time=1466148260341 2 end end=1466148262342 3 begin time=1466148262342 4 end end=1466148264378
这样也是同步的，线程获取的是同步块synchronized (this)括号（）里面的对象实例的对象锁，这里就是ObjectService实例对象的对象锁了。
4.synchronize(非this对象)
1 public class Run { 2 3 public static void main(String[] args) { 4 5 Service service = new Service("xiaobaoge"); 6 7 ThreadA a = new ThreadA(service); 8 a.setName("A"); 9 a.start(); 10 11 ThreadB b = new ThreadB(service); 12 b.setName("B"); 13 b.start(); 14 15 } 16 17 } 18 19 class Service { 20 21 String anyString = new String(); 22 23 public Service(String anyString){ 24 this.anyString = anyString; 25 } 26 27 public void setUsernamePassword(String username, String password) { 28 try { 29 synchronized (anyString) { 30 System.out.println("线程名称为：" + Thread.currentThread().getName() 31 + "在" + System.currentTimeMillis() + "进入同步块"); 32 Thread.sleep(3000); 33 System.out.println("线程名称为：" + Thread.currentThread().getName() 34 + "在" + System.currentTimeMillis() + "离开同步块"); 35 } 36 } catch (InterruptedException e) { 37 // TODO Auto-generated catch block 38 e.printStackTrace(); 39 } 40 } 41 42 } 43 44 class ThreadA extends Thread { 45 private Service service; 46 47 public ThreadA(Service service) { 48 super(); 49 this.service = service; 50 } 51 52 @Override 53 public void run() { 54 service.setUsernamePassword("a", "aa"); 55 56 } 57 58 } 59 60 61 class ThreadB extends Thread { 62 63 private Service service; 64 65 public ThreadB(Service service) { 66 super(); 67 this.service = service; 68 } 69 70 @Override 71 public void run() { 72 service.setUsernamePassword("b", "bb"); 73 74 } 75 76 }
不难看出，这里线程争夺的是anyString的对象锁，两个线程有竞争同一对象锁的关系，出现同步。
5.静态synchronize同步方法
1 public class Run { 2 3 public static void main(String[] args) { 4 5 ThreadA a = new ThreadA(); 6 a.setName("A"); 7 a.start(); 8 9 ThreadB b = new ThreadB(); 10 b.setName("B"); 11 b.start(); 12 13 } 14 15 } 16 17 class Service { 18 19 synchronized public static void printA() { 20 try { 21 System.out.println("线程名称为：" + Thread.currentThread().getName() 22 + "在" + System.currentTimeMillis() + "进入printA"); 23 Thread.sleep(3000); 24 System.out.println("线程名称为：" + Thread.currentThread().getName() 25 + "在" + System.currentTimeMillis() + "离开printA"); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 } 30 31 synchronized public static void printB() { 32 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" 33 + System.currentTimeMillis() + "进入printB"); 34 System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" 35 + System.currentTimeMillis() + "离开printB"); 36 } 37 38 } 39 40 41 class ThreadA extends Thread { 42 @Override 43 public void run() { 44 Service.printA(); 45 } 46 47 } 48 49 50 class ThreadB extends Thread { 51 @Override 52 public void run() { 53 Service.printB(); 54 } 55 }
运行结果：
1 线程名称为：A在1466149372909进入printA 2 线程名称为：A在1466149375920离开printA 3 线程名称为：B在1466149375920进入printB 4 线程名称为：B在1466149375920离开printB
两个线程在争夺同一个类锁，因此同步。
6.synchronize(class)
1 class Service { 2 3 public static void printA() { 4 synchronized (Service.class) { 5 try { 6 System.out.println("线程名称为：" + Thread.currentThread().getName() 7 + "在" + System.currentTimeMillis() + "进入printA"); 8 Thread.sleep(3000); 9 System.out.println("线程名称为：" + Thread.currentThread().getName() 10 + "在" + System.currentTimeMillis() + "离开printA"); 11 } catch (InterruptedException e) { 12 e.printStackTrace(); 13 } 14 } 15 16 } 17 18 public static void printB() { 19 synchronized (Service.class) { 20 System.out.println("线程名称为：" + Thread.currentThread().getName() 21 + "在" + System.currentTimeMillis() + "进入printB"); 22 System.out.println("线程名称为：" + Thread.currentThread().getName() 23 + "在" + System.currentTimeMillis() + "离开printB"); 24 } 25 } 26 }
运行结果：
1 线程名称为：A在1466149372909进入printA 2 线程名称为：A在1466149375920离开printA 3 线程名称为：B在1466149375920进入printB 4 线程名称为：B在1466149375920离开printB
两个线程依旧在争夺同一个类锁，因此同步。
总结：
A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制