线程池&Lambda表达式【JAVA基础】

线程池：

• 问题需求：
  如果并发线程数量很多，并且每个线程都是执行一个很短的任务就结束了，这样频繁的创建线程，
  会降低系统的效率，因为频繁创建线程和销毁线程需要时间，–线程池可以使线程复用。

• 线程池的概念：容器->集合

• 线程池的使用：
  线程池的使用步骤：
  1.使用线程池的工厂类Executor里面提供的静态方法newFixedThreadPool产生一个指定线程数量的线程池
  2.创建一个类，实现Runnable接口，重写run方法，设置线程任务。
  3.调用ExecutorService中的方法submit,传递线程任务(实现类)，开启线程，执行run方法。
  4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

代码：

线程池

package 黑马_线程池_Lambda表达式;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池：JDK1.5之后提供的
 * java.util.cocurrent.Executors：线程池的工厂类，用来生成线程池
 * Executors类中的静态方法：
 *   static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池。
 *   参数：  
 *      int nThreads:创建线程池中包含的线程数量
 *   返回值：
 *      ExecutorService接口：返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口接收(面向接口编程)
 *      
 *      
 *   ExecutorService接口：
 *         用来从线程池中获取线程，调用start方法，执行线程任务
 *           submit(Runnable task)提交一个Runnable任务用于执行
 *         关闭/销毁线程池中的方法
 *           void shutdown()
 *           
 *    线程池的使用步骤：
 *       1.使用线程池的工厂类Executor里面提供的静态方法newFixedThreadPool产生一个指定线程数量的线程池
 *       2.创建一个类，实现Runnable接口，重写run方法，设置线程任务。
 *       3.调用ExecutorService中的方法submit,传递线程任务(实现类)，开启线程，执行run方法。
 *       4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)              
 */
public class ThreadPoolDemo1 {

	public static void main(String[] args) {
		// 1.使用线程池的工厂类Executor里面提供的静态方法newFixedThreadPool产生一个指定线程数量的线程池
		ExecutorService ex = Executors.newFixedThreadPool(2);
		
		// 3.调用ExecutorService中的方法submit,传递线程任务(实现类)，开启线程，执行run方法。
		ex.submit(new RunnableImpl());
		ex.submit(new RunnableImpl());
		ex.submit(new RunnableImpl());
		ex.submit(new RunnableImpl());
		ex.submit(new RunnableImpl());
		ex.submit(new RunnableImpl());
		
		//4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)    
		ex.shutdown();
	}

}

线程实现类

package 黑马_线程池_Lambda表达式;
/**
 * 线程实现类
 */
public class RunnableImpl implements Runnable{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
	}

}

运行截图

使用Lambda表达式简化以上代码：

package 黑马_线程池_Lambda表达式;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class LambdaDemo {
	public static void main(String[] args) {

		// 1.使用线程池的工厂类Executor里面提供的静态方法newFixedThreadPool产生一个指定线程数量的线程池
		ExecutorService ex = Executors.newFixedThreadPool(2);
		
		// 3.调用ExecutorService中的方法submit,传递线程任务(实现类)，开启线程，执行run方法。
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
		ex.submit(new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
		}
		));
	
		
		//4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)    
		ex.shutdown();
		
		
	}

}

Lambda表达式：(jdk1.8的新特性)

• 函数式编程思想：
  面向对象的思想：做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。
  函数式编程思想：只要能获取到结果，谁去做怎么做都不重要，重视结果，不重视过程。

• Lambda的使用前提：
  1.使用Lambda必须具有接口，且要求接口中有且只有一个抽象方法。
  2.使用Lambda必须具有上下文推断。

• Lambda表达式的标准格式：
  由三部分组成：
  a.一些参数
  b.一个箭头
  c.一段代码
  格式：
  (参数列表)->{一些重写方法的代码};
  符号：
  ()：接口中抽象方法的参数列表。
  ->：传递，把参数传递给方法体{}。
  {}：重写接口的抽象方法的方法体。

• 使用：

package 黑马_线程池_Lambda表达式;
/*
 * 需求：
 *    给定一个厨子cook接口，内含一个唯一的抽象方法makeFood,且无参数，无返回值。
 *    使用Lambda的标准格式调用invokeFood方法。
 */
public class LambdaTest1 {
	
	
	//定义一个方法，内部调用cook接口中的makeFood方法
	public static void invokeCook(Cook cook) {
		cook.makeFood();
	}
		

	public static void main(String[] args) {
	
		//不使用Lambda表达式
//		invokeCook(new Cook() {
//			@Override
//			public void makeFood() {
//				System.out.println("吃饭了");
//				
//			}
//			
//		});	
//		
		
		//使用Lambda的标准格式调用invokeFood方法。
		invokeCook(()->{
			System.out.println("吃饭了");
		});
		
			
	}
}

• Lambda表达式的省略格式：
  可以省略的内容；
  1.参数列表：括号中参数列表的数据类型可以省略。
  2.参数列表：括号中的参数只有一个，那么类型和()都可以省略
  3.方法体：如果{}中只有一行，必须一起省略{}、return、分号。