java8使用Lambda表达式编写并发

1.提倡使用非阻塞性IO

阻塞性IO对于大量的数据的支持性并不是很好，如果有大量的IO操作等待执行，那么使用阻塞性IO就会降低整个程序的性能。
相反，使用非阻塞性IO就可以节省大量的时间。
通过名字就能明白，阻塞性IO就是在进行IO操作时，程序无法做其他的事情，只能等待IO完成后，在继续进行程序。
非阻塞行IO就是在进行IO操作的同时，软件可以做其他的事情。

2.回调

package intf;

public interface CallBack {

	default void callBack(){
		System.out.println("callBack default call back");
	}
	
}

package intf;

public interface Student {

	default void answer(CallBack callBack){
		System.out.println("student default answer");
		callBack.callBack();
	}
	
}

package intf;

public interface Teacher extends CallBack{

	default void question(Student student){
		System.out.println("teacher default question");
		student.answer(this);
	}
	
}

package main;

import intf.CallBack;
import intf.Student;
import intf.Teacher;

import org.junit.Test;

public class Main {

	@Test
	public void test(){
		new Teacher() {
			@Override
			public void question(Student student){
				Teacher.super.question(student);
				System.out.println("inner teacher");
			}
			@Override
			public void callBack(){
				Teacher.super.callBack();
				System.out.println("inner callBack");
			}
		}.question(new Student() {
			@Override
			public void answer(CallBack callBack){
				Student.super.answer(callBack);
				System.out.println("inner student");
			}
		});
	}
	
}

teacher default question
student default answer
callBack default call back
inner callBack
inner student
inner teacher

3.Lambda化

package intf;

@FunctionalInterface
public interface CallBack {

//	default void callBack(){
//		System.out.println("callBack default call back");
//	}
	
	void callBack();
}

package intf;

@FunctionalInterface
public interface Student {

//	default void answer(CallBack callBack){
//		System.out.println("student default answer");
//		callBack.callBack();
//	}
	
	void answer(CallBack callBack);
	
}

package intf;

@FunctionalInterface
public interface Teacher{

//	default void question(Student student){
//		System.out.println("teacher default question");
//		student.answer(this);
//	}
	
	void question(Student student);
	
}

	@Test
	public void test(){
		CallBack callBack = () -> System.out.println("callBack");
		Teacher Wangteacher = (student) -> {
			System.out.println("Wang teacher");
			student.answer(callBack);
		};
		Student zhangStudent = (cal) -> {
			System.out.println("Zhang student");
			cal.callBack();
		};
		Wangteacher.question(zhangStudent);
	}

Wang teacher
Zhang student
callBack

4.末日金字塔

可以看到未Lambda化的代码现在只是两层，如果有多层，那么随着缩进，代码都被挤到屏幕的右侧。
这种随着调用关系的增加，代码有规律的右移现象被称为末日金字塔（不知道是谁起的这个名字）
末日金字塔是良好代码风格的一个反例，在if语句，匿名内部类等情况下比较多见，特别是if语句中，如果if的层数大于2层，很容易发生末日金字塔的情况。
所以开发时尽可能的避免出现末日金字塔问题。

如果现在的代码已经出现末日金字塔的问题，那么尽快进行重构是一个非常明智的选择。

5.Future

Future像一张欠条，方法返回不是一个值，而是返回一个Future对象。
方法一开始执行的时候，返回一个欠条，等待一段时间后，可以使用欠条换钱。

需要注意：
Future对象的get方法会阻塞当前线程进行阻塞性获取值。

源码

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

使用Future容易因为调用get方法造成阻塞

6.CompletableFuture

CompletableFuture结合了回调和Future的思想：

使用CompletableFuture与使用Stream类似，拥有许多的方法可以调用。

CompletableFuture最常用的情景之一是异步执行一段代码，然后返回执行结果。

7.supplyAsync

有一个工厂方法，用来创建异步的CompletableFuture实例。

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }

    static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                     Supplier<U> f) {
        if (f == null) throw new NullPointerException();
        CompletableFuture<U> d = new CompletableFuture<U>();
        e.execute(new AsyncSupply<U>(d, f));
        return d;
    }

 @SuppressWarnings("serial")
    static final class AsyncSupply<T> extends ForkJoinTask<Void>
            implements Runnable, AsynchronousCompletionTask {
        CompletableFuture<T> dep; Supplier<T> fn;
        AsyncSupply(CompletableFuture<T> dep, Supplier<T> fn) {
            this.dep = dep; this.fn = fn;
        }

        public final Void getRawResult() { return null; }
        public final void setRawResult(Void v) {}
        public final boolean exec() { run(); return true; }

        public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
                if (d.result == null) {
                    try {
                        d.completeValue(f.get());
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
                d.postComplete();
            }
        }
    }

很明显的看出这个工厂方法执行的操作：
1.返回一个CompletableFuture实例
2.使用传入的Executor执行
3.使用内部类定义的方式进行许多费时的操作，但是因为使用了CompletableFuture的实例，所以初始化的线程与当前线程不是同一个线程。

需要注意的问题：
CompletableFuture实例并不是保证完成的。在线程执行的过程中发生异常，可能会导致线程异常，最后得不到返回值。
那么这个欠条就是坏账了。。

8.CompletableFuture一些常用方法

• 在链的末端执行一些代码不返回任何值：thenAccepy,thenRun
• 转换CompletableFuture的值，类似Stream的map方法：thenApply
• 当CompletableFuture出现异常时，可以使用exceptionally方法恢复，接受函数，返回替代值
• 存在一个map，既包含正常情况的结果，又包括异常情况的结果：handle
• 当CompletableFuture存在异常时，需要调试到底是什么问题：isDone,isCompleted,Exceptionally

9.响应式编程

RxJava类库
响应式编程：发膜护发的返回值从单一的返回值推广到数据流。
响应式编程实际是一种声明式编程。

举个例子：
在excel表格中，在某个单元格写下=B1+5.
这个时候就定义了这个单元格的值的运算规则。当B1格子填入数据后，这个格子的数据也就自动填充了，而且B1的值发生改变时，这个格子的值也会发生改变。

10.总结

时间驱动和响应式应用正在变得越来月流行，而且经常是最好的问题建模的方式之一。
相比阻塞式设计，这两种情况特别适合使用响应式或者时间驱动的方式思考。

• 1.业务逻辑本身就是使用事件来描述。Twitter,图形化。。。
• 2.需要同时处理大量的IO操作。阻塞式IO需要同时使用大量线程，会导致大量锁之间的竞争和太多的上下文切换。所以使用非阻塞性IO是一个更好的选择。

java8相关的源码：