Java中多线程synchronized的用法
在Java中synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。
而synchronized底层是通过使用对象的监视器锁（monitor）来确保同一时刻只有一个线程执行被修饰的方法或者代码块。
对于同步控制，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
Synchronized修饰的对象：
1.修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象（对象锁）；
2.修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象（对象锁）；
3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象（类锁）；
4.修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象（类锁）。
从上面的锁对象可以看出，Synchronized修饰的锁对象其实就2种：对象锁，类锁。
解释：
（1）对象锁：Synchronized修饰非静态方法、代码块（引入的是对象是：非静态变量、非类）；
非静态方法：
public synchronized void method(){// todo}
非静态变量：
private Object o = new Object(); public void method(){ //o 锁定的对象 synchronized(o){ // todo } }
非类（这个可以与类对比，就可以明白）：
public void method(){ //方法里的this 指的是当前的方法，方法锁 synchronized(this){ // todo } }
测试：
1）当多个线程使用同一个对象sync1，即：
SyncThread sync1 = new SyncThread(); Thread thread1 = new Thread(sync1, "thread1"); Thread thread2 = new Thread(sync1, "thread2"); thread1.start(); thread2.start();
因为线程thread1与thread2引入同一个对象sync1，属于同一个锁对象，所以线程执行是按照先执行thread1后释放锁，thread2才能获取锁并执行其方法。
2）当多个线程使用不同对象sync1与sync2，即：
SyncThread sync1 = new SyncThread(); SyncThread sync2 = new SyncThread(); Thread thread1 = new Thread(sync1, "thread1"); Thread thread2 = new Thread(sync2, "thread2"); thread1.start(); thread2.start();
因为线程thread1与thread2引入不同对象sync1与sync2，属于不同锁对象，所以线程thread1与thread2并行执行方法。
（2）类锁：Synchronized修饰静态方法、代码块（引入的是对象是：静态变量、类）；
静态方法：
public synchronized static void method(){// todo}
静态变量：
private static Object o = new Object(); public void method(){ //o 锁定的对象 synchronized(o){ // todo } }
类（与非类对比，就可以明白）：
class SyncThread implements Runnable{ public void method(){ synchronized(SyncThread.class){ // todo 同步代码块 } } public void run(){ method(); } }
测试：
1）当多个线程使用同一个对象,还是不同对象，即：
Thread thread1 = new Thread(对象1, "thread1"); Thread thread2 = new Thread(对象2, "thread2"); thread1.start(); thread2.start();
线程thread1与thread2肯定是按照先后顺序执行，即：先执行thread1后，才能执行thread2。
总结：
（1）如果synchronized引入的锁对象是类锁（该类所有的对象同一把锁），那么多个线程访问该锁锁定的功能时，肯定是有先后顺序的，而不能同时执行。
（2）如果synchronized引入的锁对象是方法锁，那么多个线程访问该锁锁定的功能时，要区分是是不是同一个锁对象，是同一个锁对象，功能与类锁类似；否则，多个线程可以同时执行该锁锁定的功能。
具体功能详解与代码示例：
1.1修饰代码块
1、synchronized修饰代码块：
说明：一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。
例子：
public class SyncThread implements Runnable { private static int count; public SyncThread(){ count = 0; } @Override public void run() { synchronized (this) { //锁对象是该方法，即方法锁 for (int i = 0; i < 5; i++) { try { System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); } } } } public static int getCount() { return count; } }
测试代码：
public class SyncThreadTest { public static void main(String[] args) { SyncThread sync = new SyncThread(); Thread thread1 = new Thread(sync, "thread1"); Thread thread2 = new Thread(sync, "thread2"); thread1.start(); thread2.start(); } }
测试结果：
当前线程名称thread1:0 当前线程名称thread1:1 当前线程名称thread1:2 当前线程名称thread1:3 当前线程名称thread1:4 当前线程名称thread2:5 当前线程名称thread2:6 当前线程名称thread2:7 当前线程名称thread2:8 当前线程名称thread2:9
结果分析：
当并发的2个线程（thread1，thread2）访问同一个对象（sync）中的synchronized代码块时，同一个时刻只能被一个线程访问；而另一个线程只能被堵塞，且必须要等待当前线程访问完，并获取已释放对象锁，才能访问该同步的代码块。线程Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象（同一个对象sync），只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。
那怎么才能引入不同的对象？
修改一下测试代码：
public class SyncThreadTest { public static void main(String[] args) { SyncThread sync1 = new SyncThread(); SyncThread sync2 = new SyncThread(); Thread thread1 = new Thread(sync1, "thread1"); Thread thread2 = new Thread(sync2, "thread2"); thread1.start(); thread2.start(); } }
测试结果：
当前线程名称thread1:0 当前线程名称thread2:1 当前线程名称thread2:3 当前线程名称thread1:2 当前线程名称thread1:4 当前线程名称thread2:5 当前线程名称thread2:6 当前线程名称thread1:7 当前线程名称thread2:8 当前线程名称thread1:9
结果分析：
不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行？
原因：这时创建了2个SyncThread对象分别为sync1和sync2，线程thread1执行的是对象sync1中的run；而线程thread2执行的是对象sync2中的run。由于2个不同的对象sync1和sync2，synchronized会为它们分别分配2个对象锁，而这2把锁是互不干扰，不形成互斥关系，所以会并行执行。
2、代码块中引入不同的对象，即指定对象上加锁：（成员变量，类变量-静态变量）
public class SynchronizedObjectDemo { //静态的全局变量，类变量(可以是自定义对象) private static Object staticObject = new Object(); //非静态变量，成员变量(可以是自定义对象) private Object o = new Object(); /** * 功能描述: <br> * 类变量的方法上锁 */ public void printStaticObject(){ synchronized (staticObject) { //staticObject是静态变量，即类变量上锁 try { //调用线程休眠5秒,锁竞争效果更加明显 Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); }finally{ //输出表示被调用 System.out.println(System.currentTimeMillis()+" printByStaticObj is called"); } } } /** * 功能描述: <br> * 在成员变量上锁的方法 */ public void printObj(){ synchronized (o) { //o是成员变量 try { //调用线程休眠5秒,锁竞争效果更加明显 Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); }finally{ //输出表示被调用 System.out.println(System.currentTimeMillis()+" printByObj is called"); } } } public static void main(String[] args) { //定义一个线程组 ThreadGroup tgroups = new ThreadGroup(Thread.currentThread().getThreadGroup(), "SynchronizedObjectDemo"); //循环，每次启动一个线程 for (int i = 0; i < 5 ; i++) { //每一个线程，重新构造对象 final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo(); //构造新线程的时候把它加入到定义的线程组 Thread obj = new Thread(tgroups, new Runnable() { @Override public void run() { syncObj.printObj(); } }); obj.start(); } while (true) {//直到定义的线程组中的线程都终止才执行后续步骤 if(tgroups.activeCount() == 0){ for (int i = 0; i < 5; i++) { final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo(); //构造新线程的时候把它加入到定义的线程组 Thread obj = new Thread(tgroups, new Runnable() { @Override public void run() { syncObj.printStaticObject(); } }); obj.start(); } break; } } } }
分析：
从这个输出结果可以看出，其实对于一个类变量加锁就类似给静态方法加锁，需要注意的一点是静态方法锁定的是Class对象，而由于类变量全局只有一个，所以行为是类似静态方法，但是锁定的不是同一个对象。
同样，而对于一个成员变量加锁就类似给非静态方法加锁。
注意：如果把第一次for循环中的SynchronizedObjectDemo对象的构造放到第一次for循环之前的话，输出的结果就会类似第二次for循环了，因为此时锁的是同一个对象。
除此之外还可以有其他方式指定锁对象：
方式一（作为方法参数）：
public void method3(SomeObject obj){ //obj 锁定的对象 synchronized(obj){ // todo } }
方式二（当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁，如上面的Object对象，但是并不是最经济的方式）：
class Test implements Runnable{ private byte[] lock = new byte[0]; // 特殊的instance变量 public void method(){ synchronized(lock) { // todo 同步代码块 } } public void run() { } }
说明：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3、当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
代码示例：
public class Counts implements Runnable { private int count; public Counts(){ count = 0; } //synchronized方法 public void countAdd(){ synchronized (this) { for (int i = 0; i < 5; i++) { try { System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); } } } } //非synchronized方法,未对count进行写操作，所以可以不用synchronized public void countRead(){ for (int i = 0; i < 5; i++) { try { System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + count); Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); } } } @Override public void run() { String threadName = Thread.currentThread().getName(); if (threadName.equals("A")) { countAdd(); } else if (threadName.equals("B")) { countRead(); } } }
测试代码：
public class CountsTest { public static void main(String[] args) { Counts counter = new Counts(); Thread thread1 = new Thread(counter, "A"); Thread thread2 = new Thread(counter, "B"); thread1.start(); thread2.start(); } }
测试结果：
当前线程名称A:0 当前线程名称B:1 当前线程名称A:1 当前线程名称B:2 当前线程名称A:2 当前线程名称B:3 当前线程名称A:3 当前线程名称B:3 当前线程名称B:4 当前线程名称A:4
结果分析：
上面代码中countAdd是一个synchronized的，countRead是非synchronized的。从上面的结果中可以看出，在线程A访问synchronized的countAdd方法过程中，线程B可以同时访问非synchronized的countRead方法。也就是说：一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块，而不受阻塞。
1.2修饰方法
1.修饰非静态方法
说明：Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，
public synchronized void method(){//todo};
synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个方法。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。
Synchronized作用于整个方法的写法。
写法一：
public synchronized void method(){ // todo }
写法二：
public void method(){ synchronized(this) { // todo } }
写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。
注意点：
（1）synchronized关键字不能继承。
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分。因此，synchronized关键字不能被继承。
如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。
当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
示例代码如下：
1）在子类方法中加上synchronized关键字
父类：
class Parent { public synchronized void method() { } }
子类：
class Child extends Parent { public synchronized void method() { } }
2）在子类方法中调用父类的同步方法
父类：
class Parent { public synchronized void method() { } }
子类：
class Child extends Parent { public void method() { super.method(); } }
（2）在定义接口方法时不能使用synchronized关键字。
（3）构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
2．修饰静态方法
代码示例：
public class StaticMethod implements Runnable{ private static int count; public StaticMethod(){ count = 0; } //静态方法 public synchronized static void getCounts(){ //属于类级别的锁，对于不同对象不可同时进入同一个类 for (int i = 0; i < 5; i++) { try { System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); } } } @Override public synchronized void run() { //属于方法级别的锁，对于不同对象可同时进入 getCounts(); } }
测试代码：
public class StaticMethodTest { public static void main(String[] args) { StaticMethod sync1 = new StaticMethod(); StaticMethod sync2 = new StaticMethod(); Thread thread1 = new Thread(sync1, "thread1"); Thread thread2 = new Thread(sync2, "thread2"); thread1.start(); thread2.start(); } }
结果分析：
sync1和sync2是StaticMethod的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法getCounts，而静态方法是属于类的，所以sync1和sync2相当于用了同一把锁。这与非静态方法是不同的。
1.3修饰一个类
说明：对于类锁，有几种方式：（1）synchronized修饰静态方法；（2）synchronized修饰静态变量；（3）synchronized代码块中直接引入类名称。前2种方式，前面已经做了详细的解释，这里主要解释第三种。
代码示例：
class ClassName { public void method() { synchronized(ClassName.class) { // todo } } }
synchronized作用于一个类ClassName时，是给这个类ClassName加锁，ClassName的所有对象用的是同一把锁。
参考资料：
http://www.importnew.com/21866.html
