使用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() {
			
			@Override
			public void run() {
				while(true) {
					try {
						Thread.sleep(5);
					} catch (Exception e) {
						e.printStackTrace();
					}
					
					// 输出某个字符串
					// 在这个匿名类里，我们需要把outputer变量定义为final
					outputer.output("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
				}
			}
		}).start();
		

		// 第二个线程
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					try {
						Thread.sleep(50);
					} catch (Exception e) {
						e.printStackTrace();
					}
					
					// 输出某个字符串
					// 在这个匿名类里，我们需要把outputer变量定义为final
					outputer.output("5555555555555555555");
				}
			}
		}).start();
		
	} // end of init
	
	class 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() {
			
			@Override
			public void run() {
				while(true) {
					try {
						Thread.sleep(10);
					} catch (Exception e) {
						e.printStackTrace();
					}
					
					// 输出某个字符串
					// 调用的是output_1
					outputer.output_1("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
				}
			}
		}).start();
		

		// 第二个线程
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					try {
						Thread.sleep(10);
					} catch (Exception e) {
						e.printStackTrace();
					}
					
					// 输出某个字符串
					// 调用的是output_2
					outputer.output_2("5555555555555555555");
				}
			}
		}).start();
		
	} // end of init
	

	static 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.class
			synchronized (Outputer.class) {
				for(int i=0; i<length; i++) {
					// 逐个字母输出
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
}

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

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