java8的lambdas表達式模擬aop思想，封裝一下鎖功能

           java8的lambdas，其實在編譯後，會變爲此類中的方法，lambdas表達式只不過是一種簡單的語法。lambdas表達式其實就是模擬的c，c++語言中的函數指針，這兩個語言均可以把函數看成方法的參數傳遞，但java中就不行了，由於java中一切都是類，方法必須依附於類而存活。

        這就免不了java8以前出現的匿名類。不過java8簡化了語法，但和命名類仍是有實質的區別。咱們能夠利用aop思想，封裝一下通用邏輯，客戶端沒必要要考慮的非業務邏輯，而那些業務邏輯就能夠經過lambdas表達式傳入。

     如今看一下ReentrantReadWriteLock的這中aop思想的體現代碼：

package com.doctor.java8;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * simplifying-readwritelock-with-java-8-and-lambdas 這也是利用aop編程思想
 * 
 * @see http://www.javacodegeeks.com/2014/03/simplifying-readwritelock-with-java-8-and-lambdas.html
 * 
 * @author doctor
 *
 * @time 2015年4月20日 下午2:48:19
 */
public class SimplifyingReadwritelockWithJava8AndLambdas {

	public static void main(String[] args) {

		MyBuffer myBuffer = new MyBuffer(2);
		myBuffer.put("name");
		myBuffer.put("name1");
		myBuffer.put("name2");
		System.out.println(myBuffer.getRecent());
		System.out.println(myBuffer.getDiscardedCount());

	}

	private static class MyBuffer {
		private final int capacity;
		private final Deque<String> recent;
		private int discarded;
		private final FunctionalReadWriteLock guard;

		public MyBuffer(final int capacity) {
			this.capacity = capacity;
			recent = new ArrayDeque<String>(this.capacity);
			discarded = 0;
			guard = new FunctionalReadWriteLock();
		}

		public void put(String value) {
			guard.write(() -> {
				while (recent.size() >= capacity) {
					recent.removeFirst();
					discarded++;
				}
				recent.add(value);
			});
		}

		public List<String> getRecent() {
			return guard.read(this::defensiveCopyOfRecent);
		}

		private List<String> defensiveCopyOfRecent() {
			return recent.stream().collect(Collectors.toList());
		}

		public int getDiscardedCount() {
			return guard.read(() -> {
				return discarded;
			});
		}

		public int getTotal() {
			return guard.read(() -> {
				return discarded + recent.size();
			});
		}

		public void flush() {
			guard.write(this::unsafeFlush);
		}

		private void unsafeFlush() {
			discarded += recent.size();
			recent.clear();
		}
	}

	private static class FunctionalReadWriteLock {

		private final Lock readLock;
		private final Lock writeLock;

		public FunctionalReadWriteLock() {
			this(new ReentrantReadWriteLock());
		}

		public FunctionalReadWriteLock(final ReentrantReadWriteLock readWriteLock) {
			readLock = readWriteLock.readLock();
			writeLock = readWriteLock.writeLock();
		}

		public void read(Runnable runnable) {
			readLock.lock();
			try {
				runnable.run();
			} finally {
				readLock.unlock();
			}
		}

		public <T> T read(Supplier<T> supplier) {
			readLock.lock();
			try {
				return supplier.get();
			} finally {
				readLock.unlock();
			}
		}

		public void write(Runnable runnable) {
			writeLock.lock();
			try {
				runnable.run();
			} finally {
				writeLock.unlock();
			}
		}

		public <T> T write(Supplier<T> supplier) {
			writeLock.lock();
			try {
				return supplier.get();
			} finally {
				writeLock.unlock();
			}
		}
	}
}