使用流处理大数据集

Java 9并发编程指南 目录

Stream接口是可以进行筛选和转换的元素序列,以顺序或并行的方式得到最终结果。此结果可以是原始数据类型(整型、长整型…),对象或者数据结构。如下特性更好的定义了Stream:

  • 流是数据序列,不是数据结构。
  • 可以将不同的源创建成流,例如集合(列表、数组…)、文件、字符串或提供流元素的类。
  • 无法访问单独的流元素。
  • 无法修改的流的来源。
  • 流定义了两类操作:中间操作创建新的Stream接口,用来转换、筛选、映射或者排序流元素;终点操作生成操作的最终结果。流管道是由零或多个中间操作以及一个最终操作组成。
  • 中间操作是懒加载的,它们在终点操作开始执行之前是不会执行的。如果Java检测到不影响操作的最终结果,则避免在元素或流的一组元素上执行中间操作。

当需要实现以并发形式处理大数据集的操作时,可以使用Java并发API的不同元素来实现,从Java线程到fork/join框架再到执行器框架,但我任务并行流是最好的选择。本节将实现范例来解释使用并行流的优势。

准备工作

本范例通过Eclipse开发工具实现。如果使用诸如NetBeans的开发工具,打开并创建一个新的Java项目。

实现过程

通过如下步骤实现范例:

  1. 创建名为Person的类,此类有六个属性来定义人员的基本特性。我们将实现这些属性值的get()和set()方法,在这里不列出:

    public class Person {
    	private int id;
    	private String firstName;
    	private String lastName;
    	private Date birthDate;
    	private int salary;
    	private double coeficient;
    
  2. 现在实现名为PersonGenerator的类。此类只有一个名为generatedPersonList()的方法,用来生成Person对象列表,此列表具有随机值,大小在参数中指定。源码如下:

    public class PersonGenerator {
    	public static List<Person> generatePersonList (int size) {
    		List<Person> ret = new ArrayList<>();
    		String firstNames[] = {"Mary","Patricia","Linda", "Barbara","Elizabeth","James", "John","Robert","Michael","William"};
    		String lastNames[] = {"Smith","Jones","Taylor", "Williams","Brown","Davies", "Evans","Wilson","Thomas","Roberts"};
    		Random randomGenerator=new Random();
    		for (int i=0; i<size; i++) {
    			Person person=new Person();
    			person.setId(i);
    			person.setFirstName(firstNames[randomGenerator.nextInt(10)]);
    			person.setLastName(lastNames[randomGenerator.nextInt(10)]);
    			person.setSalary(randomGenerator.nextInt(100000));
    			person.setCoeficient(randomGenerator.nextDouble()*10);
    			Calendar calendar=Calendar.getInstance();
    			calendar.add(Calendar.YEAR, -randomGenerator.nextInt(30));
    			Date birthDate=calendar.getTime();
    			person.setBirthDate(birthDate);
    			ret.add(person);
    		}
    		return ret;
    	}
    }
    
  3. 实现名为PersonMapTask的任务,主要目的是将人员列表转换成映射,其中键是人员名称,值将是名称与键相同的Person对象列表。我们使用fork/join框架实现这个转换,所以PersonMapTask继承RecursiveAction类:

    public class PersonMapTask extends RecursiveAction{
    
  4. PersonMapTask有两个私有属性:待处理的Person对象列表和存储结果的ConcurrentHashMap。使用类构造函数初始化这两个属性:

    	private List<Person> persons;
    	private ConcurrentHashMap<String, ConcurrentLinkedDeque<Person>> personMap;
    	
    	public PersonMapTask(List<Person> persons, ConcurrentHashMap<String, ConcurrentLinkedDeque<Person>> personMap) {
    		this.persons = persons;
    		this.personMap = personMap;
    	}
    
  5. 实现compute()方法,如果列表元素小于1000,处理这些元素并插入到ConcurrentHashMap。使用computeIfAbsent()方法得到与键关联的列表,如果映射中不存在这个键,则生成一个新的ConcurrentMapedDeque对象:

    	@Override
    	protected void compute() {
    		if (persons.size() < 1000) {
    			for (Person person: persons) {
    				ConcurrentLinkedDeque<Person> personList=personMap.computeIfAbsent(person.getFirstName(), name -> {
    					return new ConcurrentLinkedDeque<>();
    				});
    				personList.add(person);
    			}
    			return;
    		}
    
  6. 如果列表元素大于1000,创建两个子任务,拆分列表进行处理:

    		PersonMapTask child1, child2;
    		child1=new PersonMapTask(persons.subList(0,persons.size()/2), personMap);
    		child2=new PersonMapTask(persons.subList(persons.size()/2, persons.size()), personMap);
    		invokeAll(child1,child2);
    	}
    }
    
  7. 最后实现包含main()方法的Main类。首先,生成具有10000个随机Person对象的列表:

    public class Main {
    	public static void main (String[] args) {
    		List<Person> persons=PersonGenerator.generatePersonList(100000);
    
  8. 然后,比较两个方法,将名称作为键(列表的一部分)和Person作为值生成映射。List将使用并行流函数和使用groupingByConcurrent()采集器的collect()方法:

    		Date start, end;
    		start = new Date();
    		Map<String, List<Person>> personsByName = persons.parallelStream().collect(Collectors.groupingByConcurrent(p -> p.getFirstName()));
    		end = new Date();
    		System.out.printf("Collect: %d - %d\n", personsByName.size(), end.getTime()-start.getTime());
    
  9. 第二种方式是使用fork/join框架和PersonMapTask类:

    		start = new Date();
    		ConcurrentHashMap<String, ConcurrentLinkedDeque<Person>> forkJoinMap=new ConcurrentHashMap<>();
    		PersonMapTask personMapTask=new PersonMapTask(persons,forkJoinMap);
    		ForkJoinPool.commonPool().invoke(personMapTask);
    		end = new Date();
    		System.out.printf("Collect ForkJoinPool: %d - %d\n", forkJoinMap.size(), end.getTime()-start.getTime());
    	}
    }
    

工作原理

本节实现相同算法的两个不同版本,将List转换成Map。如果执行的话,将得到相同的结果和近似的执行时间。使用流的最大优势是实现方式简单且减少开发时间,只需要一行代码就能够实现。在另一个版本中,我们使用当前数据结构实现新的类(PersonMapTask),然后在fork/join框架中执行。

使用流能够将算法划分为简单的步骤,并优雅的表示且易于编程和理解。

更多关注

  • 第六章“并行和响应式流”中的“创建不同来源的流”、“归约流元素”和“排序流元素”小节。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值