Java 9并发编程指南 目录

锁与其它同步机制一样，定义了一次只能执行一个线程的临界区。必须非常谨慎的定义临界区，它必须只包含真正需要互斥的指令。尤其是其包含长操作，如果临界区包含不使用共享资源的冗长操作，则性能将更差。

本节将实现分别在临界区内和临界区外执行长操作任务的范例，查看这两种情况下的性能差异。

准备工作

本范例通过Eclipse开发工具实现。如果使用诸如NetBeans的开发工具，打开并创建一个新的Java项目。

实现过程

通过如下步骤实现不可变类：

1. 创建名为Operations的类：

   public class Operations {
   

2. 实现名为readData()的公有静态方法，设置当前线程休眠500毫秒：

   	public static void readData(){
   		try {
   			TimeUnit.MILLISECONDS.sleep(500);
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   	}
   

3. 实现名为writeData()的公有静态方法，设置当前线程休眠500毫秒：

   	public static void writeData(){
   		try {
   			TimeUnit.MILLISECONDS.sleep(500);
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   	}	
   

4. 实现名为processData()的公有静态方法，设置当前线程休眠2秒：

   	public static void processData(){
   		try {
   			TimeUnit.SECONDS.sleep(2);
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   	}
   }
   

5. 实现名为Task1的类，指定其实现Runnable接口：

   public class Task1 implements Runnable{
   

6. 声明名为lock的私有Lock属性：

   	private final Lock lock;
   

7. 实现类构造函数，初始化属性：

   	public Task1 (Lock lock) {
   		this.lock=lock;
   	}
   

8. 实现run()方法，获得锁，调用Operation类的三个操作，然后释放锁：

   	@Override
   	public void run() {
   		lock.lock();
   		Operations.readData();
   		Operations.processData();
   		Operations.writeData();
   		lock.unlock();
   	}
   }
   

9. 实现名为Task2的类，指定其实现Runnable接口：

   public class Task2 implements Runnable{
   

10. 声明名为lock的私有Lock属性：

    	private final Lock lock;
    

11. 实现类构造函数，初始化属性：

    	public Task2 (Lock lock) {
    		this.lock=lock;
    	}
    

12. 实现run()方法，获得锁，调用readData()操作然后释放锁，调用processData()方法，获得锁，调用writeData()操作，然后释放锁：

    	@Override
    	public void run() {
    		lock.lock();
    		Operations.readData();
    		lock.unlock();
    		Operations.processData();
    		lock.lock();
    		Operations.writeData();
    		lock.unlock();
    	}
    }
    

13. 实现本范例主类，创建名为Main的类，包含main()方法：

    public class Main {
    	public static void main(String[] args) {
    

14. 创建名为lock的Lock对象，名为task1的Task1对象，名为task2的Task2对象，以及10个线程的数组：

    		Lock lock=new ReentrantLock();
    		Task1 task1=new Task1(lock);
    		Task2 task2=new Task2(lock);
    		Thread threads[]=new Thread[10];
    

15. 加载10个线程，通过控制执行时间，执行第一个任务：

    		Date begin, end;
    		begin=new Date();
    		for (int i=0; i<threads.length; i++) {
    			threads[i]=new Thread(task1);
    			threads[i].start();
    		}
    		for (int i=0; i<threads.length; i++) {
    			try {
    				threads[i].join();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		end=new Date();
    		System.out.printf("Main: First Approach: %d\n", (end.getTime()-begin.getTime()));
    

16. 加载10个线程，通过控制执行时间，执行第二个任务：

    		begin=new Date();
    		for (int i=0; i<threads.length; i++) {
    			threads[i]=new Thread(task2);
    			threads[i].start();
    		}
    		for (int i=0; i<threads.length; i++) {
    			try {
    				threads[i].join();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		end=new Date();
    		System.out.printf("Main: Second Approach: %d\n", (end.getTime()-begin.getTime()));
    	}
    }
    

工作原理

如果执行本范例，会发现两种方法的执行时间有很大的不同。所有操作在临界区里的任务执行时间要比另一个任务长很多。

当要实现用锁保护的代码块时，要仔细分析只包含必要的操作。将方法分割成不同的临界区，必要时使用多个锁以获得应用的最佳性能。