java run方法完美写法_Java巧用lambda，异步方法优雅写法

了解lambda的基本原理

加入lambda之后，很多写法都变得简单起来，如创建一个线程对象，可以：

new Thread(new Runnable() {

@Override

public void run() {

System.out.print("Hello");

}

});

lambda写法:

new Thread(() -> System.out.print("Hello"));

单独将lambda拎出来：

Runnable runnable = () -> System.out.print("Hello");

其实lambda代表的就是一个接口的实现而已(匿名内部类)。而这种接口也叫函数式接口，会有@FunctionalInterface注解进行编译时检查。

或者直接把lambda看成一个方法，上述的 () -> System.out.print("Hello") 就是代表一个无入参、无返回值的一个方法(等同于public void run() {System.out.print("Hello")})，而Runnable runnable则是指向这个方法(类似函数指针)，需要调用这个方法时，调用runnable.run()即可.

当有一个参数、无返回值则是Consumer

// 对printStream对象的void print(String s)方法的引用

PrintStream printStream = System.out;

Consumer consumer = printStream::print;

consumer.accept("Hello");

// 输出

Hello

对于有入参(一个或两个)、有返回值等情况，JDK也提供了对应的函数式接口：

接口

函数

说明

Consumer

void accept(T t)

无返回值、一个入参，T为入参类型

BiConsumer

void accept(T t, U u)

无返回值、两个入参，T为第一个入参类型、U为第二个入参类型

Supplier

T get()

有返回值、无入参，T为返回值类型

Function

R apply(T t)

有返回值、一个入参，T为入参类型，R为返回类型

BiFunction

R apply(T t, U u)

有返回值、两个入参，T为第一个入参类型、U为第二个入参类型，R为返回类型

以上为java.util.function包下的部分接口，剩余的基本上就是指定泛型类型的函数接口了，例如LongConsumer，无泛型，其实就是指定入参只能是Long。

上述已经代表了大部分的函数可以表示的形式了(值得注意的是，三个及以上的入参的函数式接口JDK并没有提供，需要时要自定义实现，实际上也很少用到)。

方法有静态方法(static)和非静态方法，但函数式接口关注的仅是入参、出参类型和个数而已：

public Class Test {

public Long noStaticFoo(String str) {...}

public static Long staticFoo(String str) {...}

public static void main() {

// 静态方法，类::

Function staticFoo = Test::staticFoo;

Long apply = staticFoo.apply("100");

// 非静态方法，实例对象::

Test test = new Test();

Function noStaticFoo = test::noStaticFoo;

Long apply2 = noStaticFoo.apply("100");

/* 这种可以理解成两个入参、除了原来方法的入参外，还要指明实例对象(因为这是一个实例方法)*/

BiFunction noStaticFooTest = Test::noStaticFoo;

Long apply3 = noStaticFooTest.apply(test, "100");

}

}

当一个函数/方法可以被变量引用时，其实就可以利用这个特性做一些比较方便的事情了，例如Streams的相关API。效率也比反射中的Method要高。

优雅的异步方法调用写法

在java中的异步方法，原理基本上大同小异，其实就是新开一个线程(或者从线程池中获取线程)，Spring也提供相应的@Async注解。这里期待的是，将业务代码与“系统是否异步执行”进行解耦。

假如我现在有个Service，里面有个方法是根据id远程拉取用户信息(HTTP)：

public class UserHttpService {

public User getById(Long id) {

...

return user;

}

}

有A、B、C三个地方有调用到UserHttpService#getById，我们发现A处同步发起了好几个HTTP请求(拉取用户信息只是其中一个)，这时候我希望UserHttpService#getById能变成异步执行，提高效率。一种做法是@Async + 直接修改返回值为Future，但是问题来了，这样的话B、C两个地方都要做出修改，但是B、C只调了一个HTTP，没必要变成异步呀(事实上，在真实项目中，情况会比这个更加复杂)。另外一种做法则是结合lambda进行解耦。

先新增一个异步执行类：

public class AsyncExecutor {

// 线程池，建议恰当配置(拒绝策略建议CallerRunsPolicy)和使用框架注入

private ExecutorService executorService = Executors.newFixedThreadPool(10);

/**

* 单个入参，有返回值的异步执行方法 , public User getById(Long id)

*

* @param method 要执行的方法，如 , userHttpService::getById

* @param param 入参值，如 100

* @param

入参类型，如 Long

* @param 返回值类型,如 User

* @return Future对象，用以判断是否执行结束、获取返回结果

*/

public

Future async(Function

method, P param) {

return executorService.submit(() -> method.apply(param));

}

}

这时候A处异步调用：

public class A {

private AsyncExecutor asyncExecutor;

private UserHttpService userHttpService;

public void foo() {

...

// 异步调用

Future userFuture = asyncExecutor.async(userHttpService::getById, id);

... 其他操作(如再发起http请求)

// 获取结果

User user = userFuture.get();

...

}

}

对于原来的UserHttpService并不需要做任何修改，只要在需要的地方(A)指定为异步即可。

对于其他的无入参、两入参、无返回值等的方法形式，也可以类似处理：

public class AsyncExecutor {

// 线程池，建议恰当配置(拒绝策略建议CallerRunsPolicy)和使用框架注入

private ExecutorService executorService = Executors.newFixedThreadPool(10);

/**

* 无入参，无返回值的异步执行方法 , void noStaticFoo()

*

* @param method 要执行的方法，如 user::noStaticFoo;

* @return Future对象，用以判断是否执行结束

*/

public Future async(Runnable method) {

return executorService.submit(method);

}

/**

* 有单个入参，无返回值的异步执行方法，如 void noStaticFoo(Long id)

*

* @param method 要执行的方法，如, user::noStaticFoo

* @param param 方法执行的入参，如id

* @param

入参类型，如Long

* @return Future对象，用以判断是否执行结束

*/

public

Future async(Consumer

method, P param) {

return executorService.submit(() -> method.accept(param));

}

/**

* 有两个参数但是无返回值的异步执行方法, 如void noStaticFoo(Long id,Entity entity)

*

* @param method 要执行的方法，如 , user::noStaticFoo

* @param param1 第一个入参值，如id

* @param param2 二个入参值，如entity

* @param 第一个入参类型

* @param 第二个入参类型

* @return Future对象，用以判断是否执行结束

*/

public Future async(BiConsumer method, P1 param1, P2 param2) {

return executorService.submit(() -> method.accept(param1, param2));

}

/**

* 无参数有返回值的异步执行方法 , Entity noStaticFoo()

*

* @param method 要执行的方法，如 , user::noStaticFoo

* @param 返回值类型,如 Entity

* @return Future对象，用以判断是否执行结束、获取返回结果

*/

public Future async(Supplier method) {

return executorService.submit(method::get);

}

/**

* 单个入参，有返回值的异步执行方法 , Entity noStaticFoo(Long id)

*

* @param method 要执行的方法，如 , user::noStaticFoo

* @param param 入参值，如 id

* @param

入参类型，如Long

* @param 返回值类型,如 Entity

* @return Future对象，用以判断是否执行结束、获取返回结果

*/

public

Future async(Function

method, P param) {

return executorService.submit(() -> method.apply(param));

}

/**

* 两个入参，有返回值的异步执行方法 , Entity noStaticFoo(Long id)

*

* @param method 要执行的方法，如 , user::noStaticFoo

* @param param1 第一个入参值，如id

* @param param2 二个入参值，如entity

* @param 第一个入参类型

* @param 第二个入参类型

* @param 返回值类型,如 Entity

* @return Future对象，用以判断是否执行结束、获取返回结果

*/

public Future async(BiFunction method, P1 param1, P2 param2) {

return executorService.submit(() -> method.apply(param1, param2));

}

}

JDK1.8 有提供CompletableFuture，也是类似异步处理的方法，默认线程池为ForkJoinPool(默认最大工作线程数=CPU总核心数-1)，该线程池擅长于计算密集型任务，IO密集型任务请尽量使用自己合理配置的线程池。