使用synchronized需要注意的一个问题

我们知道，在java中，每个对象都持有一把对象锁，这是在java语言层实现的机制（不同于java.util.concurrent包的lock），因此不需要显式去释放锁。

当我们谈到synchronized这个关键字，大伙第一时间想到的，可能就是：当资源共享时,访问(修改)该资源的所有方法都要加上锁(synchronized),才能保证数据不会出错(数据不一致)；

Java提供了专门的机制去避免了同一个数据对象被多个线程同时访问，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：

public synchronized void foo(int i);

2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject) {
      //  允许访问控制的代码
      //  其中的代码块必须获得对象syncObject的锁才能执行
}

如果方法A和方法B都对同一个对象加了synchronized，并且在方法A中调用了方法B；假设有某个线程T调用方法A，线程T也不需要在A调用方法B时等待该 对象锁 释放从而在方法B中又持有该对象的锁，因为synchronized 不是方法级的，而是线程级的；因此，线程T在A方法的时候，就已经获得了那个对象的锁了。

而我们这里所要探讨的，就是synchronized块的参数；而synchronized 块里的代码必须要获得对象 syncObject （可以是类实例或类）的锁方能执行。

首先我们来模拟两个线程，逐个字母输出某个字符串：

package com.gdut.thread;public class SynchronizedTest {public static void main(String[] args) {new SynchronizedTest().init();}public void init() {final Outputer outputer = new Outputer();// 第一个线程new Thread(new Runnable() {@Overridepublic void run() {while(true) {try {Thread.sleep(5);} catch (Exception e) {e.printStackTrace();}// 输出某个字符串// 在这个匿名类里，我们需要把outputer变量定义为finaloutputer.output("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");}}}).start();// 第二个线程new Thread(new Runnable() {@Overridepublic void run() {while(true) {try {Thread.sleep(50);} catch (Exception e) {e.printStackTrace();}// 输出某个字符串// 在这个匿名类里，我们需要把outputer变量定义为finaloutputer.output("5555555555555555555");}}}).start();} // end of initclass Outputer {public void output(String name) {int length = name.length();for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}}

上面这段程序是线程不安全的，我们来看看它的部分输出：

对此，我们有一种比较省事的做法，直接在Output类的output方法加上关键字synchronized，即：public synchronized void output(String name) { }

我们也还有另外一种方法，就是synchronized块，而这里便涉及到synchronized块里面的参数；

通俗一点的说法就是：

当A线程执行到synchronized块的时候，A会去检查参数对象的锁有没有给其他线程拿走，如果没拿走，则线程A拿走该对象的锁，并且在线程A执行unlock前不允许其他线程执行该对象锁的所有synchronied块。

但是下面这段代码同样是线程不安全的，原因就在synchronized块的参数name是一个局部变量，也就是说，当A，B两个线程执行到这的时候，都会去执行synchronized块里面的代码！

class Outputer {public void output(String name) {int length = name.length();synchronized(name) {for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}}

运行结果：

把参数对象改成" this " 或者是Outputer类的成员变量str，都可以解决这个问题：

class Outputer {// String str = "";public void output(String name) {int length = name.length();// synchronized(str) {// 这里的"this"表示调用该方法的那个对象，即init方法的 final Outputer outputer = new Outputer();// 如果A，B线程各自new Outputer()对象，这样又是不同步的了！synchronized(this) {for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}}

===============================

接下来，我们继续看一下下面的这个例子：

package com.gdut.thread;public class SynchronizedTest {public static void main(String[] args) {new SynchronizedTest().init();}public void init() {final Outputer outputer = new Outputer();// 第一个线程new Thread(new Runnable() {@Overridepublic void run() {while(true) {try {Thread.sleep(10);} catch (Exception e) {e.printStackTrace();}// 输出某个字符串// 调用的是output_1outputer.output_1("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");}}}).start();// 第二个线程new Thread(new Runnable() {@Overridepublic void run() {while(true) {try {Thread.sleep(10);} catch (Exception e) {e.printStackTrace();}// 输出某个字符串// 调用的是output_2outputer.output_2("5555555555555555555");}}}).start();} // end of initstatic class Outputer {public void output_1(String name) {int length = name.length();synchronized (this) {for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}public static synchronized void output_2(String name) {int length = name.length();for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}}

output_1和output_2的区别是：前者是synchronized块，而后者是static方法！输出的结果同样是有问题的，如下：

也就是说，和static方法关联的对象，并不是this，而是某个Class类！(这里的的Class为：java.lang.Class)把output_1方法稍做修改，即可：

public void output_1(String name) {int length = name.length();// 参数对象为Outputer.classsynchronized (Outputer.class) {for(int i=0; i<length; i++) {// 逐个字母输出System.out.print(name.charAt(i));}System.out.println();}}

这样同步的问题又解决了！！

在最后，建议大伙都学习一下java.util.concurrent包里面的相关知识！