java-jdk1.5新增的并发包内容

1.各种同步控制工具的使用：

1.1 ReentrantLock

  1.1.1 可重入

    ReentrantLock和Synchronized比较：

       ReentrantLock：需要在finally进行释放锁，且可以重入，即可以反复得到相同的一把锁，它有一个与锁相关的计数器，如果拥有锁的某个线程再次得到这把锁，这个计数器将会+1，然后锁需要释放两次才需要真正释放。

       Synchronized:释放锁是由JVM实现的。当这把锁被一个线程所占据，其他线程只能等待这把锁被释放，才可以进入。

      相比之下，ReentrantLock比Synchronized性能更好，如果只是简单的实现，建议使用Synchronized，不要刻意使用ReentrantLock。

   下图是使用Synchronized的代码及效果展示：

package test;

public class TestTest1 implements Runnable {

	public synchronized void method2() {
		System.out.println("method2=" + Thread.currentThread().getId());
		method1();
	}

	public synchronized void method1() {
		System.out.println("method1=" + Thread.currentThread().getId());
	}

	@Override
	public void run() {
		method2();
	}

	public static void main(String[] args) {
		TestTest1 test = new TestTest1();
		Thread thread1=new Thread(test);
		thread1.start();
		Thread thread2=new Thread(test);
		thread2.start();
		Thread thread3=new Thread(test);
		thread3.start();
	}

}

输出如下图所示：
           

使用ReentrantLock的代码及效果展示：

package test;

import java.util.concurrent.locks.ReentrantLock;

public class TestTest2 implements Runnable {
	ReentrantLock lock = new ReentrantLock();

	public void get() {
		lock.lock();
		System.out.println("get=" + Thread.currentThread().getId());
		set();
		//lock.unlock();
	}

	public void set() {
		lock.lock();
		System.out.println("set=" + Thread.currentThread().getId());
		lock.unlock();
	}

	@Override
	public void run() {
		get();
	}

	public static void main(String[] args) {
		TestTest2 test = new TestTest2();
		Thread thread1 = new Thread(test);
		thread1.start();
		Thread thread2 = new Thread(test);
		thread2.start();
		Thread thread3 = new Thread(test);
		thread3.start();
	}

}

从结果可以看出，使用ReentrantLock,需要手动释放锁，否则就会等待。 

将代码注释去掉，就等同于Synchronized,结果如下：

也可以在finally块中加入lock.unlock();

   1.1.2 可中断

  ReentrantLock中的lock.lockInterruptibly(),可以捕捉到中断的异常，而lock.lock()则不能，示例如下：

package test;

import java.util.concurrent.locks.ReentrantLock;

public class TestTest3 implements Runnable {
	static ReentrantLock lock = new ReentrantLock();

	@Override
	public void run() {
		lock.lock();
//		try {
//			lock.lockInterruptibly();
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
		System.out.println(Thread.currentThread().getName() + " interrupted");
	}

	public static void main(String[] args) {
		lock = new ReentrantLock();
		lock.lock();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
		TestTest3 test = new TestTest3();
		try {
			Thread thread1 = new Thread(test);
			thread1.start();
			Thread.sleep(1000);
			thread1.interrupt();
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

}

结果显示没有报异常，只是一直在休眠。

而把lock.lock()注释掉，使用lock.lockInterruptibly(),可以捕捉到异常，如下图所示：

这就证明了其可中断性。

总结：

1. 线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，
    如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断
    如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情

2.ReentrantLock获取锁定与三种方式：
     a) lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
     b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
     c)tryLock(long timeout,TimeUnit unit)， 如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
     d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断

3.synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中