java中的synchronized和Lock

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。

java.util.concurrent.locks包下常用的类

首先，我们先看一下Lock接口的API：

public interface Lock {
    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

lock()：该方法用来获取锁。
如下：

Lock lock = new ReentrantLock();
lock.lock();
try {
	System.out.println(t.getName()+"获得了锁");
} catch (InterruptedException e) {
	e.printStackTrace();
} finally {
	System.out.println(t.getName()+"释放了锁");
	lock.unlock();
}

注意：在finally块中释放锁，目的是保证锁一定会被释放，防止死锁的发生。
不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，异常抛出的同时，也会导致锁无故释放。

lockInterruptibly()：可中断地获取锁，和lock()方法不同的是该方法会响应中断，即在锁的获取中可以中断当前线程。
如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B处于等待中，对线程B调用threadB.interrupt()会中断线程B的等待过程。
注意：当一个线程获取了锁之后，是不会被interrupt()方法中断的。只能中断阻塞中的线程。

tryLock()：尝试非阻塞的获取锁，调用该方法后立刻返回，如果能够获取则返回true，否则返回false。
一般如下格式：

Lock lock = new ReentrantLock();
if(lock.tryLock()) {
	try {
		System.out.println(t.getName()+"获得了锁");
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();
		System.out.println(t.getName()+"释放了锁");
	}
}else {
	System.out.println(t.getName()+"获得锁失败");
}

tryLock(long time, TimeUnit unit)：超时的获取锁，当前线程在以下3种情况下会返回：
① 当前线程在超时时间内获得了锁
② 当前线程在超时时间内被中断
③ 超时时间结束，返回false

可重入锁

重入锁ReentrantLock，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁还支持获取锁时的公平和非公平性选择，这里我们对公平性不细说。

其实synchronized关键字支持的锁也是重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。比如：当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

class Test{
    public synchronized void method1() {
        method2();
    }
     
    public synchronized void method2() {
         
    }
}

假若synchronized不具备可重入性，此时线程A在method1方法中调用method2方法时，需要重新申请锁，这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

public class TestLock {
	
	Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		final TestLock tl = new TestLock();
		new Thread() {
			@Override
			public void run() {
				tl.insert(Thread.currentThread());				
			}
		}.start();
		
		new Thread() {
			@Override
			public void run() {
				tl.insert(Thread.currentThread());
			}
		}.start();
	}

	
	public void insert(Thread t) throws InterruptedException {
		lock.lock();
		try {
			System.out.println(t.getName()+"获得了锁");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			System.out.println(t.getName()+"释放了锁");
			lock.unlock();
		}
	}
	
}

输出结果：
Thread-0获得了锁
Thread-0释放了锁
Thread-1获得了锁
Thread-1释放了锁

public class TestLock {
	
	Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		final TestLock tl = new TestLock();
		new Thread() {
			@Override
			public void run() {				
				tl.test(Thread.currentThread());									
			}
		}.start();
		
		new Thread() {
			@Override
			public void run() {				
				tl.test(Thread.currentThread());				
			}
		}.start();
	}
	
	public void test(Thread t) {
		if(lock.tryLock()) {
			try {
				System.out.println(t.getName()+"获得了锁");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
				System.out.println(t.getName()+"释放了锁");
			}
		}else {
			System.out.println(t.getName()+"获得锁失败");
		}
	}
	
}	

输出结果：
Thread-0获得了锁
Thread-1获得锁失败
Thread-0释放了锁

public class TestLock {
	
	Lock lock = new ReentrantLock();

	public static void main(String[] args) {
		final TestLock tl = new TestLock();			
		Thread t1 = new Thread(new MyThread(tl));
		Thread t2 = new Thread(new MyThread(tl));
		t1.start();
		t2.start();
		t2.interrupt();
	}
	
	public void insert(Thread t) throws InterruptedException {
		lock.lockInterruptibly();//该方法会响应中断获取锁
		try {
			System.out.println(t.getName()+"获得了锁");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			System.out.println(t.getName()+"释放了锁");
			lock.unlock();
		}
	}
	
}


class MyThread implements Runnable{
	TestLock tl;
	public MyThread(TestLock tl) {
		this.tl = tl;
	}
	@Override
	public void run() {
		try {
			tl.insert(Thread.currentThread());
		} catch (InterruptedException e) {
			System.out.println(Thread.currentThread().getName()+"被中断");
		} 
	}
	
}

输出结果：
Thread-0获得了锁
Thread-1被中断
Thread-0释放了锁

ReadWriteLock也是一个接口，它表示读写锁。里面有2个方法，一个用来获取读锁，一个用来获取写锁，ReentrantReadWriteLock是ReadWriteLock的实现类。

下面来看一下读写锁的具体用法，假如多个线程同时进行读操作，看一下synchronized的效果：

public class TestReadWriteLock {	
	public static void main(String[] args) {
		final TestReadWriteLock trw = new TestReadWriteLock();
		new Thread() {
			@Override
			public void run() {
				trw.get(Thread.currentThread());
			}
		}.start();

		new Thread() {
			@Override
			public void run() {
				trw.get(Thread.currentThread());
			}
		}.start();
	}

	public synchronized void get(Thread thread) {
		long start = System.currentTimeMillis();
        
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
	}
	
}

输出结果：
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
…
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
…
Thread-1读操作完毕

如果改成读写锁，效果如下：

public class TestReadWriteLock {	
	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

	public static void main(String[] args) {
		final TestReadWriteLock trw = new TestReadWriteLock();
		new Thread() {
			@Override
			public void run() {
				trw.get1(Thread.currentThread());
			}
		}.start();

		new Thread() {
			@Override
			public void run() {
				trw.get1(Thread.currentThread());
			}
		}.start();
	}

	public void get1(Thread thread) {
		lock.readLock().lock();
        try {
            long start = System.currentTimeMillis();             
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        } finally {
        	lock.readLock().unlock();
        }
	}
}

输出结果：
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
…
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
…
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1读操作完毕

通过以上可以2种不同的方式可以看出，读锁是同时进行的，而synchronized每次只能允许一个锁。

通过以上总结一下Lock与synchronized的区别。
1）Lock是一个接口，而synchronized是Java中的关键字，是代码级的，synchronized是内置的语言实现，是JVM级的；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
6）Lock可以实现公平锁，synchronized只能是非公平的。

注意：与synchronized对应的Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的Lock（确切的说是同步器）拥有一个同步队列和多个等待队列。