码迷,mamicode.com
首页 > 编程语言 > 详细

java8的lambdas表达式模拟aop思想,封装一下锁功能

时间:2015-04-21 10:01:05      阅读:161      评论:0      收藏:0      [点我收藏+]

标签:

           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();
			}
		}
	}
}


java8的lambdas表达式模拟aop思想,封装一下锁功能

标签:

原文地址:http://my.oschina.net/doctor2014/blog/404073

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!