java多線程並發中應用Lockers類將多線程同享資本鎖定

package com.yao;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Lockers
 * 在多線程編程外面一個主要的概念是鎖定，假如一個資本是多個線程同享的，為了包管數據的完全性，
 * 在停止事務性操作時須要將同享資本鎖定，如許可以包管在干事務性操作時只要一個線程能對資本停止操作，
 * 從而包管數據的完全性。在5.0之前，鎖定的功效是由Synchronized症結字來完成的。
 */
public class Lockers {

 /**
  * 測試Lock的應用。在辦法中應用Lock，可以免應用Synchronized症結字。
  */
 public static class LockTest {

  Lock lock = new ReentrantLock();// 鎖
  double value = 0d; // 值
  int addtimes = 0;

  /**
   * 增長value的值，該辦法的操作分為2步，並且互相依附，必需完成在一個事務中
   * 所以該辦法必需同步，之前的做法是在辦法聲明中應用Synchronized症結字。
   */
  public void addValue(double v) {
   lock.lock();// 獲得鎖
   System.out.println("LockTest to addValue: " + v + "   "
     + System.currentTimeMillis());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   }
   this.value += v;
   this.addtimes++;
   lock.unlock();// 釋放鎖
  }

  public double getValue() {
   return this.value;
  }
 }
 public static void testLockTest() throws Exception{
  final LockTest lockTest = new LockTest();
  // 新建義務1，挪用lockTest的addValue辦法
  Runnable task1 = new Runnable(){
   public void run(){
    lockTest.addValue(55.55);
   }
  };
  // 新建義務2，挪用lockTest的getValue辦法
  Runnable task2 = new Runnable(){
   public void run(){
    System.out.println("value: " + lockTest.getValue());
   }
  };
  // 新建義務履行辦事
  ExecutorService cachedService = Executors.newCachedThreadPool();
  Future future = null;
  // 同時履行義務1三次，因為addValue辦法應用了鎖機制，所以，本質上會次序履行
  for (int i=0; i<3; i++){
   future = cachedService.submit(task1);
  }
  // 期待最初一個義務1被履行完
  future.get();
  // 再履行義務2，輸入成果
  future = cachedService.submit(task2);
  // 期待義務2履行完後，封閉義務履行辦事
  future.get();
  cachedService.shutdownNow();
 }

 /**
  * ReadWriteLock內置兩個Lock，一個是讀的Lock，一個是寫的Lock。
  * 多個線程可同時獲得讀的Lock，但只要一個線程能獲得寫的Lock，
  * 並且寫的Lock被鎖定後，任何線程都不克不及獲得Lock。ReadWriteLock供給的辦法有：
  * readLock(): 前往一個讀的lock
  * writeLock(): 前往一個寫的lock, 此lock是排他的。
  * ReadWriteLockTest很合適處置相似文件的讀寫操作。
  * 讀的時刻可以同時讀，但不克不及寫；寫的時刻既不克不及同時寫也不克不及讀。
  */
 public static class ReadWriteLockTest{
  // 鎖
  ReadWriteLock lock = new ReentrantReadWriteLock();
  // 值
  double value = 0d;
  int addtimes = 0;

  /**
   * 增長value的值，不許可多個線程同時進入該辦法
   */
  public void addValue(double v) {
   // 獲得writeLock並鎖定
   Lock writeLock = lock.writeLock();
   writeLock.lock();
   System.out.println("ReadWriteLockTest to addValue: " + v + "   "
     + System.currentTimeMillis());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   }
   try {
    // 做寫的任務
    this.value += v;
    this.addtimes++;
   } finally {
    // 釋放writeLock鎖
    writeLock.unlock();
   }
  }
  /**
   * 取得信息。當有線程在挪用addValue辦法時，getInfo獲得的信息能夠是不准確的。
   * 所以，也必需包管該辦法在被挪用時，沒無方法在挪用addValue辦法。
   */
  public String getInfo() {
   // 獲得readLock並鎖定
   Lock readLock = lock.readLock();
   readLock.lock();
   System.out.println("ReadWriteLockTest to getInfo   "
     + System.currentTimeMillis());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   }
   try {
    // 做讀的任務
    return this.value + " : " + this.addtimes;
   } finally {
    // 釋放readLock
    readLock.unlock();
   }
  }
 }

 public static void testReadWriteLockTest() throws Exception{
  final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
  // 新建義務1，挪用lockTest的addValue辦法
  Runnable task_1 = new Runnable(){
   public void run(){
    readWriteLockTest.addValue(55.55);
   }
  };
  // 新建義務2，挪用lockTest的getValue辦法
  Runnable task_2 = new Runnable(){
   public void run(){
    System.out.println("info: " + readWriteLockTest.getInfo());
   }
  };
  // 新建義務履行辦事
  ExecutorService cachedService_1 = Executors.newCachedThreadPool();
  Future future_1 = null;
  // 同時履行5個義務，個中前2個義務是task_1，後兩個義務是task_2
  for (int i=0; i<2; i++){
   future_1 = cachedService_1.submit(task_1);
  }
  for (int i=0; i<2; i++){
   future_1 = cachedService_1.submit(task_2);
  }
  // 最初一個義務是task_1
  future_1 = cachedService_1.submit(task_1);
  // 這5個義務的履行次序應當是：
  // 第一個task_1先履行，第二個task_1再履行；這是由於不克不及同時寫，所以必需等。
  // 然後2個task_2同時履行；這是由於在寫的時刻，就不克不及讀，所以都期待寫停止，
  // 又由於可以同時讀，所以它們同時履行
  // 最初一個task_1再履行。這是由於在讀的時刻，也不克不及寫，所以必需期待讀停止後，能力寫。

  // 期待最初一個task_2被履行完
  future_1.get();
  cachedService_1.shutdownNow();
 }

 public static void main(String[] args) throws Exception{
  Lockers.testLockTest();
  System.out.println("---------------------");
  Lockers.testReadWriteLockTest();
 }
}