Lambda表达式简化线程的使用

Lambda表达式

在jdk8之后才有Lambda表达式，其作用是避免匿名内部类定义过多， 其实质属于函数式编程的概念。

从外部类到Lambda表达式

Lambda表达式的出现就是为了减少匿名内部类，下面展示从外部类到Lambda表达式的演变过程，以更好地理解Lambda表达式。

package com.sxt.thread;
/**
 * lambda推导
 * 2019/7/10	17:07
 */
public class LambdaTest {
	//静态内部类
	static class Like2 implements Ilike{

		@Override
		public void lambda() {
			// TODO Auto-generated method stub
			System.out.println("i like lambda2");
		}
		
	}
	
	public static void main(String[] args) {
		Ilike like = new Like();
		like.lambda();
		
		like = new Like2();
		like.lambda();
		
		//匿名内部类
		like = new Ilike() {
			public void lambda() {
				// TODO Auto-generated method stub
				System.out.println("i like lambda3");
			}
		};
		like.lambda();
		//局部内部类
		class Like3 implements Ilike{
			public void lambda() {
				// TODO Auto-generated method stub
				System.out.println("i like lambda4");
			}
		}
		like = new Like3();
		like.lambda();
		
		//lambda推导必须存在类型
		like = ()->{
			System.out.println("i like lambda5");
		};
		like.lambda();
	}
}

interface Ilike{
	void lambda();
}

//外部类
class Like implements Ilike{

	@Override
	public void lambda() {
		// TODO Auto-generated method stub
		System.out.println("i like lambda1");
	}
	
}

从外部类到静态内部类、局部内部类、匿名内部类、Lambda表达式，从功能实现的角度看是相同的。从编译角度看，外部类在加载程序时就编译；静态内部类不使用不编译，使用时才编译；局部内部类在调用方式时编译；匿名内部类和Lambda表达式都是在使用时才编译。与前3个类不同的是，匿名内部类和Lambda表达式必须借助接口或者父类且内部只能有一个方法。

Lambda表达式的写法

Lambda表达式+不含参数

上面展示的从外部类到Lambda表达式的演变过程中的代码即为Lambda表达式+不含参数的表示方法。

Lambda表达式+含单个参数

package com.sxt.thread;
/**
 * lambda+单个参数
 * 2019/7/10	17:12
 */
public class LambdaTest2 {
	public static void main(String[] args) {
		Ilove love = (int a)->{
			System.out.println("i like lambda --> " + a);
		};
		love.lambda(100);
		
		//简化
		love = (a)->{
			System.out.println("i like lambda --> " + a);
		};
		love.lambda(50);
		
		//简化
		love = a -> {
			System.out.println("i like lambda --> " + a);
		};
		love.lambda(10);
		
		//简化
		love = a -> System.out.println("i like lambda --> " + a);
		love.lambda(5);
	}
}

interface Ilove{
	void lambda(int a);
}

class Love implements Ilove{

	@Override
	public void lambda(int a) {
		// TODO Auto-generated method stub
		System.out.println("i like lambda --> " + a);
	}
	
}

Lambda表达式+含多个参数

package com.sxt.thread;
/**
 * lambda+多个参数
 * 2019/7/10	17:30
 */
public class LambdaTest3 {
	public static void main(String[] args) {
		IInterest interest = (int a, int b)-> {
			System.out.println("i like lambda --> " + (a + b));
		};
		interest.lambda(100, 200);
		
		interest = (a, b)-> {
			System.out.println("i like lambda --> " + (a + b));
		};
		interest.lambda(200, 200);

		interest = (a, b)-> 
		System.out.println("i like lambda --> " + (a + b));
		interest.lambda(200, 300);
	}
}

interface IInterest{
	void lambda(int a,int b);
}

class Interest implements IInterest{

	@Override
	public void lambda(int a, int b) {
		// TODO Auto-generated method stub
		System.out.println("i like lambda --> " + (a + b));
	}
}

Lambda表达式+有返回值

package com.sxt.thread;
/**
 * lambda+返回值
 * 2019/7/10	17:30
 */
public class LambdaTest3 {
	public static void main(String[] args) {
		IInterest interest = (int a, int b)-> {
			System.out.println("i like lambda --> " + (a + b));
			return a + b;
		};
		System.out.println(interest.lambda(100, 200));
		
		interest = (a, b)-> {
			System.out.println("i like lambda --> " + (a + b));
			return a + b;
		};
		System.out.println(interest.lambda(200, 200));
		
		interest = (a,b)->  a+b ;
		System.out.println(interest.lambda(100, 100));
	}
}

interface IInterest{
	int lambda(int a,int b);
}

class Interest implements IInterest{

	@Override
	public int lambda(int a, int b) {
		// TODO Auto-generated method stub
		System.out.println("i like lambda --> " + (a + b));
		return a + b;
	}
}

Lambda表达式简化线程

通过以上内容的介绍可知，Lambda表达式的作用是减少匿名内部类是使用， Lambda表达式的使用包括不含参数、含单个参数、含多个参数以及含参数带返回值。本文介绍 Lambda表达式的目的是为了简化线程，用 Lambda表达式简化线程的前提是此线程只用一次。下面给出Lambda表达式简化线程的代码示例：

package com.sxt.thread;
/**
 * lambda 简化线程（用一次）的使用
 * 2019/7/10	17:12
 */
public class LambdaTest4 {
	public static void main(String[] args) {
		new Thread(()->{
			for(int i = 0; i < 10; i++) {
				System.out.println("一边学习lambda");
			}
		}).start();
		new Thread(()->{
			for(int i = 0; i < 10; i++) {
				System.out.println("一边崩溃中");
			}
		}).start();
	}
}

此处的启动线程采用了静态代理模式。