快速学习Java8新特性第六讲——并行流与串行流

拼搏现实的明天。 2023-06-22 04:26 29阅读 0赞

接下来，我将会为大家详细介绍一下并行流。之前是不是给大家简单说了一嘴，Java 8的速度变快了，之所以我们说Java 8的速度变快了，很重要的一点就是有了这个并行流，并行流起到了一个很关键的作用，它使得我们的程序很容易就能切换成一个多线程，而且更能利用CPU的资源。

# 了解Fork/Join框架 #

在讲解并行流以前，我们首先得提另外一个框架，这个框架就是Fork/Join框架，那什么是Fork/Join框架呢？所谓的**Fork/Join框架就是在必要的情况下，将一个大任务进行拆分（fork）成若干个小任务（拆到不可再拆时为止），再将一个个的小任务运算的结果进行汇总（join）。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]

# Fork/Join框架与传统线程池的区别 #

实际上，Fork/Join这个框架早在JDK1.7就已经有了，但是它的使用相对稍微的复杂一点，所以应用的并不是特别的广泛。但是Fork/Join这个框架的核心还是非常好的，因为它的效率高，为什么它的效率高呢？你只要知道了它与传统线程池之间的区别，就能明白为啥它的效率高了。那它与传统的线程池到底有什么区别呢？下面我举个例子大家就应该明白了。

就拿多线程来说，所谓的多线程就是把我们的任务分别分配到CPU不同的核上（也就是CPU不同的线程上）进行执行，比如说，以4核CPU为例。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]  
如果说是传统的线程的话，那么会存在一个什么问题呢？在使用传统线程的情况下，每一个任务都有可能阻塞。为什么会发生阻塞这种情况呢？每个线程执行的时候，什么时候执行，这是由CPU时间片给它分配的执行权决定的，当这个时间片段用完了以后，CPU会强制剥夺它的执行权，然后交给其他的线程去执行，这时就有可能出现阻塞的情况。阻塞的情况有很多种，如果说一旦某一个线程发生了阻塞的情况的话，这会造成一个什么样的结果呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
那么，现在的这个Fork/Join框架，它到底是怎么工作的呢？Fork/Join框架就是把一个大任务拆分成若干个小任务，然后它会把这些若干个小任务都压入到对应的线程当中（也就是说，它会把一个个的小任务压入到每个CPU的每个线程中，默认CPU有几核，它就利用几个线程），然后形成一个个的线程队列，形成一个个的线程队列以后，它会有什么特点呢？

这时，我们就不得不说说Fork/Join框架的核心了，即"工作窃取"模式（work-stealing），也就是说Fork/Join框架的执行采用的是"工作窃取"模式（work-stealing）。**什么叫做"工作窃取"模式（work-stealing）呢？当执行新的任务时，它可以将其拆分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。**

这说的到底是啥意思啊？就看你是怎么理解"工作窃取"模式（work-stealing）了，读者不妨可以按照我所画的图来理解。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]

## 总结 ##

相对于一般的线程池实现，Fork/Join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在Fork/Join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行，这种方式减少了线程的等待时间，提高了性能。

# 并行流 #

认识了Fork/Join框架之后，理解并行流就变得很容易了。啥是并行流呢？并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

# Fork/Join框架的简单使用 #

实际上，在JDK1.7中就已经有了Fork/Join这个框架，为什么它没有被广泛的应用呢？因为它写起来稍微有点复杂！下面我就举个例子来说明一下如何使用Fork/Join框架。例如，实现数的累加操作，比如说计算1到100亿的和。

首先，我们要编写一个类继承RecursiveTask类，并重写compute()方法。

package com.meimeixia.java8;
    
    import java.util.concurrent.RecursiveTask;
    
    /** * 实现数的累加操作，比如说计算1到100亿的和 * @author liayun * */
    public class ForkJoinCalculate extends RecursiveTask<Long> { 
    
    	/** * 提供一个序列号 */
    	private static final long serialVersionUID = 134656970987L;
    	
    	//从哪加到哪
    	private long start;
    	private long end;
    	
    	/* * 注意，在什么情况下不拆了呢？在到达临界值时，就不再继续拆了，所以还得搞一个临界值，比如说10000。 * 我不断拆，比如说我要计算1到100亿的和，那我就不断地一半一半地拆：先从1到50亿，50亿到100亿， * 1到50亿还能再拆，1到25亿，然后是25亿到50亿，然后那1到25亿还能再拆，直到拆到10000为止， * 形成线程队列，一个个地都加到我们的线程上去，形成线程微粒！ */
    	private static final long THRESHOLD = 10000;
    	
    	public ForkJoinCalculate(long start, long end) { 
    		this.start = start;
    		this.end = end;
    	}
    
    	@Override
    	protected Long compute() { 
    		long length = end - start;
    		//如果到达临界值，我就开始加
    		if (length <= THRESHOLD) { 
    			long sum = 0;
    			for (long i = start; i <= end; i++) { 
    				sum += i;
    			}
    			return sum;
    		} else {  //如果不到达临界值呢？我就要拆了，拆成一个个的子任务
    			long middle = (start + end) / 2;
    			ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
    			left.fork();//拆分成子任务，同时压入线程队列
    			
    			ForkJoinCalculate right = new ForkJoinCalculate(middle + 1, end);
    			right.fork();//拆分成子任务，同时压入线程队列
    			
    			//拆完之后，得合并，把fork()之后的结果得一个个合并，即累加总和
    			return left.join() + right.join();
    		}
    	}
    
    }

然后，编写一个单元测试类（例如TestForkJoin.java），在该单元测试类中运行以上ForkJoinCalculate类。**温馨提示：Fork/Join框架的执行，需要一个ForkJoinPool（线程池）的支持。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
大家也不妨再搞一个普通的for循环，完成上述1到100亿的累加操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
通过对比，不难发现：  
![在这里插入图片描述][2019121709133030.png]  
不知你有没有发现，计算1到1亿之间累加的和时，使用Fork/Join框架的方式居然还比传统单线程的方式慢，这是为什么呢？

其实这个原因也是很好理解的，因为Fork/Join框架执行的时候，需要不断地拆分任务，又不断地合并任务结果，这些也是需要消耗一点时间的，而任务不大可以很快就能执行完的情况下，它的fork和join操作无疑占据整个程序运行时间比例比较大。那么，如果任务很大呢？比如说我把1亿给改成100亿（结果是负数，超出了Long的范围，不过这里我们不关心结果只关心执行时间），那么对比结果就变得很明显了。这就可以说明问题了，可想而知当任务越大时，Fork/Join框架的优势就越明显。

这里，还要提到的一点是CPU的利用率，在test1()方法执行时，我的CPU的利用率如下图所示，可知CPU的所有核都用上了，心疼一把CPU！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]  
而test2()方法在执行时是下图这样子的，说明并没有充分利用到CPU。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]  
还需要注意的一点是，**拆分的临界值的设定对Fork/Join框架执行的速度也很关键**，不能太大，也不能太小，太大了没有充分拆分任务压榨CPU，太小了就会拆分过度，浪费太多时间在拆分上，以计算1到10亿之间的和为例，我把ForkJoinCalculate类中的临界值THRESHOLD从10000改成1000000，test1()方法执行时间是120毫秒左右，比上面的测试要快，说明临界值10000是太小了。但具体取哪个临界值，得自己慢慢测了，反正我不会数学推演。

# 在Java 8中使用并行流 #

Java 8对并行流进行了一个提升，也就是说对并行流进行了优化，我们可以很容易地对数据进行并行操作。例如，还是以计算1到100亿之间的和为例。

@Test
    public void test3() { 
    	Instant start = Instant.now();//使用Java 8中的新特性计算时间，得到一个时间戳
    	
    	LongStream.rangeClosed(0, 10000000000L)
    		      .parallel() //获取的是并行流
    		  	  .reduce(0, Long::sum);
    	
    	Instant end = Instant.now();
    	System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//获取毫秒值，759毫秒
    }

**温馨提示：虽然在Java 8中我们用的是parallel()方法，但是实际上底层还是用的Fork/Join框架。** 上面就已说过，Fork/Join框架执行的时候得要有一个ForkJoinPool（线程池）的支持，你有没有想过，Java 8对此做了一个什么样的更新呢？在Java 8以后，实际上也可以没有这个ForkJoinPool了，只不过，它现在给我们提供了一个公共的ForkJoinPool（线程池）了，这个池自动完成fork/join操作。

还要一点，需要我们注意，Stream API可以声明性地通过parallel()与sequential()这俩方法在并行流与顺序流之间进行切换。例如，下面就是一个使用顺序流的一个例子。

@Test
    public void test3() { 
    	Instant start = Instant.now();//使用Java 8中的新特性计算时间，得到一个时间戳
    	
    	//现在，这儿获取的就是顺序流，顺序流也就是所谓的单线程，它的效率肯定是低的
    	LongStream.rangeClosed(0, 10000000000L)
    		  	  .reduce(0, Long::sum);
    	
    	Instant end = Instant.now();
    	System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//获取毫秒值
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191213224333971.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191213233028945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191214112756821.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191214122645895.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191214124209829.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191214124217585.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[2019121709133030.png]: https://img-blog.csdnimg.cn/2019121709133030.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191217091334730.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191217091346596.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70