线程Lock

我们之前学习了synchronized，今天来介绍一下lock。lock与synchronized一样都是为了多线程在竞争公共资源时，能不发生冲突，就是一个线程获取了锁，就去执行代码块，其它线程只能等待第一个线程执行完同步代码块，才能有机会获取到synchronized锁对象。

  lock与synchronized最大的区别是，lock锁的释放需要程序员手动调用unlock,一般放在要同步的代码的最后调用unlock，或者try..catch..finally中的finally里调用unlock。当然，从lock释放锁的灵活性上来说，lock的性能更高些，因为synchronized必须等待代码块整个执行完毕才能自动释放锁，而unlock可由程序员手动释放，随时释放，只要不影响多线程同步。

synchronized与lock的示例代码如下：

 

package cn.itcast.heima2;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class LockTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new LockTest().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable(){
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outputer.output("gaoxiaowei");
				}
				
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outputer.output("liudehua");
				}
				
			}
		}).start();
		
	}

	static class Outputer{
		Lock lock = new ReentrantLock();
		public void output(String name){
			int len = name.length();
			lock.lock();
			try{
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}finally{
				lock.unlock();
			}
		}
		
		public synchronized void output2(String name){
			int len = name.length();
			for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
			}
			System.out.println();
		}
		
		public static synchronized void output3(String name){
			int len = name.length();
			for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
			}
			System.out.println();
		}	
	}
}

其中output函数使用了lock,于是两个thread不断输出字符串“gaoxiaowei”,“liudehua”，就不会乱，不会出现类似于这样的输出："gaoxliudehuaiaowei"

其中output2函数使用了synchronized ，它也可以达到多线程同步的效果。

           值得注意的是如果 生成两个Outputer对象就不行了，例如再创建一个Outputer对象,    final Outputer outputer2 = new Outputer();  然后让输出liudehua的线程（第2个new Thread） 使用outputer2.output照样会乱，例如类似于这样的输出："gaoxliudehuaiaowei"。这是因为synchronized或lock，创建的锁对象就是output对象。多线程调用同一Outputer 对象的output函数可以达到同效果，但是当一个线程使用output对象，第二个线程使用output2对象，那么这两个线程在调用output.output()函数与output2.output()函数时，是不会同步的，因为它们分别持有的锁是output.this 与 output2.this,是两把不同的锁，各自玩各自的，互相不受影响，都无法锁住对方。

 

其中其中output3函数使用了synchronized, output3注意了，是一个静态函数，synchronized关键字对应的锁对象是 Output.class类的字节码，它能锁住所有类对象，这个时候即使创建了inal Outputer outputer2 = new Outputer(); 让线程1调用 outputer.output3()，线程2调用output2.output3(), 是不会出现错乱的，因为outputer与output2都属于Output类型，synchronized关键字对应的锁对象是 Output.class类的字节码，它们在执行output3()函数时，用的是同一把锁：Output.class。因此最终还是可以达到多个线程同步输出字符串到屏幕设备的。

 

但是，无论是synchronized，还是我们上述讲的lock, 性能都很差，因为它们的锁有些盲目，比如当2个线程都是读数据，并没有去写数据，所以不会出现多线程读取多乱问题。这个时候synchronized和lock就有点死板了，当第1个线程读取变量值（或数据）的时候，线程2也想读，但是必须得等线程1把锁释放了才行，即使线程2不是来捣乱的。

要改善读-读性能问题，需要使用ReentrantReadWriteLock（读写锁）来分别创建读锁 和 写锁。读锁就能解决上述问题，让读--读自由。