Guava ---- Concurrent併發

  Guava在JDK1.5的基礎上， 對併發包進行擴展。 有一些是易用性的擴展（如Monitor）。 有一些是功能的無缺（如ListenableFuture）。 再加上一些函數式編程的特性， 使併發包的靈活性極大的提升...

Monitor的使用：

import com.google.common.util.concurrent.Monitor;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Monitor類語義和 synchronized 或者 ReentrantLocks是同樣的， 僅僅贊成一個線程進入
 */
public class MonitorSample {

    private static final int MAX_SIZE = 3;

    private Monitor monitor = new Monitor();

    private List<String> list = new ArrayList<String>();

    Monitor.Guard listBelowCapacity = new
            Monitor.Guard(monitor) {
                @Override
                public boolean isSatisfied() {
                    return list.size() < MAX_SIZE;
                }
            };

    public void addToList(String item) throws InterruptedException {
        // 超過MAX_SIZE， 會鎖死
        //monitor.enterWhen(listBelowCapacity);

        // 超過返回false  不會鎖死
        Boolean a = monitor.tryEnterIf(listBelowCapacity);
        try {
            list.add(item);
        } finally { // 確保線程會推出Monitor鎖
            monitor.leave();
        }
    }

    public static void main(String[] args) {
        MonitorSample monitorSample = new MonitorSample();
        for (int count = 0; count < 5; count++) {
            try {
                monitorSample.addToList(count + "");
            }
            catch (Exception e) {
                System.out.println(e);
            }
        }

        Iterator iteratorStringList = monitorSample.list.iterator();
        while (iteratorStringList.hasNext()) {
            System.out.println(iteratorStringList.next());
        }
    }

}

Future的擴展： 可識別的返回結果。 可改變的返回結果

package com.wenniuwuren.listenablefuture;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;

/**
 * 在使用ListenableFuture前， 最好看下JDK的Future使用
 * 
 * @author wenniuwuren
 *
 */
public class ListenableFutureTest {
	public static void main(String[] args) {
        
		
		// Guava封裝後帶有執行結束監放任務執行結束的功能
		ExecutorService executorService =
				MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
		
		ListenableFuture<String> listenableFuture = (ListenableFuture<String>) executorService
				.submit(new Callable<String>() {
					public String call() throws Exception {
						return "task success ";
					}
				});
		
		/* Futrue初始版本號
		 
		// JDK 自帶線程池
		//ExecutorService executor = Executors.newCachedThreadPool();
		
		// JDK Future
		Future<Integer> future = executor.submit(new Callable<Integer>() {
			public Integer call() throws Exception {
				return 1;
			}
		});
		
		// JDK Future真正獲取結果的地方
		try {
			Integer count = future.get();
		} catch (Exception e) {
			e.printStackTrace();
		}*/
		
		
		/* listenableFuture 結束監聽版本號
		// 相比JDK的Future等待結果， Guava採用監聽器在任務完畢時調用
		// 但是有個缺陷， 對最後完畢的結果無法對操做成功/失敗進行處理， 即run方法沒返回值
		listenableFuture.addListener(new Runnable() {
			@Override
			public void run() {
				System.out.println("執行完畢");
			}
		}, executorService);*/
		
		// 執行成功。將會返回 "task success successfully"  攻克了listenableFuture 結束監聽版本號不能對結果進行操做問題
		FutureCallbackImpl callback = new FutureCallbackImpl();
		// 和計算結果同步執行
		//Futures.addCallback(listenableFuture, callback);
		
		//假設計算較大， 結果的訪問使用異步  將會使用executorService線程去異步執行
		Futures.addCallback(listenableFuture, callback, executorService);
		
		System.out.println(callback.getCallbackResult());
		
		
	}

}



class FutureCallbackImpl implements FutureCallback<String> {
	private StringBuilder builder = new StringBuilder();

	@Override
	public void onSuccess(String result) {
		builder.append(result).append("successfully");
	}

	@Override
	public void onFailure(Throwable t) {
		builder.append(t.toString());
	}

	public String getCallbackResult() {
		return builder.toString();
	}
}