Collections After Eight. Maurice Naftalin Morningside Light

Transcription

1

2 Collections After Eight Maurice Naftalin Morningside Light

3 Maurice Naftalin Developer, designer, architect, teacher, learner, writer 3

4 Maurice Naftalin Developer, designer, architect, teacher, learner, writer Co-author 3

5 Maurice Naftalin Developer, designer, architect, teacher, learner, writer Co-author Current Project 3

6 First computer I programmed Varian 620/i 4

7 Why is everyone so rude about us? 5

8 Why is everyone so rude about us? 90% of all Java programs are written by morons. 5

9 Why is everyone so rude about us? 90% of all Java programs are written by morons. If Java had true garbage collection, most programs would delete themselves upon execution. 5

10 Why is everyone so rude about us? 90% of all Java programs are written by morons. If Java had true garbage collection, most programs would delete themselves upon execution. Lambdas aren t a new invention so why did it take Java so long to incorporate them? IIRC even COBOL had something like them. 5

11 Why is everyone so rude about us? 90% of all Java programs are written by morons. If Java had true garbage collection, most programs would delete themselves upon execution. Lambdas aren t a new invention so why did it take Java so long to incorporate them? IIRC even COBOL had something like them. Sufficiently advanced Java is indistinguishable from satire. 5

12 Why is everyone so rude about us? 90% of all Java programs are written by morons. If Java had true garbage collection, most programs would delete themselves upon execution. Lambdas aren t a new invention so why did it take Java so long to incorporate them? IIRC even COBOL had something like them. Sufficiently advanced Java is indistinguishable from satire. Java is the new Cobol 5

13 Is it because we write code like this? Code plucked from a personal project // check each deadlined Plan. If it can t be done in time for its deadline, return the Plan // that caused the problem; otherwise, return null. private Plan checkplans(list<plan> deadlinedplans) { Plan problemplan = null; Iterator<Plan> planitr = deadlinedplans.iterator(); while (planitr.hasnext() && problemplan == null) { Plan plan = planitr.next(); problemplan = checkplan(plan); return problemplan; 6

14 Is it because we write code like this? Code plucked from a personal project // check each deadlined Plan. If it can t be done in time for its deadline, return the Plan // that caused the problem; otherwise, return null. private Plan checkplans(list<plan> deadlinedplans) { Plan problemplan = null; Iterator<Plan> planitr = deadlinedplans.iterator(); while (planitr.hasnext() && problemplan == null) { Plan plan = planitr.next(); problemplan = checkplan(plan); return problemplan; 6

15 Could we improve our image? 7

16 Could we improve our image? Wouldn t it be cool if instead of writing this: private Plan checkplans(list<plan> deadlinedplans) { Plan problemplan = null; Iterator<Plan> planitr = deadlinedplans.iterator(); while (planitr.hasnext() && problemplan == null) { Plan plan = planitr.next(); problemplan = checkplan(plan); return problemplan; 7

17 Could we improve our image? private Plan checkplans(list<plan> deadlinedplans) { Plan problemplan = null; Iterator<Plan> planitr = deadlinedplans.iterator(); Wouldn t it be cool if instead of writing this: while (planitr.hasnext() && problemplan == null) { Plan plan = planitr.next(); problemplan = checkplan(plan); return problemplan; we could write this: private Optional<Plan> checkplans( List<Plan> deadlinedplans) { return deadlinedplans.stream(). map(p -> checkplan(p)). filter(p -> p!= null). findfirst(); 7

18 Could we improve our image? private Plan checkplans(list<plan> deadlinedplans) { Plan problemplan = null; Iterator<Plan> planitr = deadlinedplans.iterator(); Wouldn t it be cool if instead of writing this: while (planitr.hasnext() && problemplan == null) { Plan plan = planitr.next(); problemplan = checkplan(plan); return problemplan; And easily make it execute in parallel??! we could write this: private Optional<Plan> checkplans( List<Plan> deadlinedplans) { return deadlinedplans.stream(). map(p -> checkplan(p)). filter(p -> p!= null). findfirst(); 7

19 Presentation Overview The Magic Ingredient Result: Better APIs Result: More Parallelism 8

20 Take values to a higher order 9

21 Take values to a higher order instead of supplying values to specific library methods public interface Collection<E> {... boolean remove(object o);... 9

22 Take values to a higher order instead of supplying values to specific library methods public interface Collection<E> {... boolean remove(object o);... we re going to supply behaviour to general library methods: public interface Collection<E> {... boolean removeif(predicate<? super E> p);... 9

23 Take values to a higher order higher-order values instead of supplying values to specific library methods public interface Collection<E> {... boolean remove(object o);... we re going to supply behaviour to general library methods: public interface Collection<E> {... boolean removeif(predicate<? super E> p);... 9

24 Take values to a higher order higher-order values instead of supplying values to specific library methods public interface Collection<E> {... boolean remove(object o);... we re going to supply behaviour to general library methods: public interface Collection<E> {... boolean removeif(predicate<? super E> p);... Predicate is an interface with a single abstract boolean-valued method test removeif executes test for each element: if test returns true, removeif removes that element 9

25 Take values to a higher order higher-order values instead of supplying values to specific library methods public interface Collection<E> {... boolean remove(object o);... we re going to supply behaviour to general library methods: public interface Collection<E> {... boolean removeif(predicate<? super E> p);... Predicate is an interface with a single abstract boolean-valued method Whaat? test removeif executes test for each element: if test returns true, removeif removes that element 9

26 How to make an interface instance? Using an anonymous inner class, of course! planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) { return p.equals(problemplan); ); 10

27 How to make an interface instance? Using an anonymous inner class, of course! planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) { return p.equals(problemplan); ); Maybe this is why they re so rude about us? 10

28 Let s strip out the boilerplate! Why do we have to say we re supplying a Predicate? Why do we have to say we re implementing test, the only abstract method? planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) { return p.equals(problemplan) ); 11

29 Let s strip out the boilerplate! Why do we have to say we re supplying a Predicate? Why do we have to say we re implementing test, the only abstract method? planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) p { return p.equals(problemplan) ); 11

30 Let s strip out the boilerplate! Why do we have to say we re supplying a Predicate? Why do we have to say we re implementing test, the only abstract method? planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) p {-> return p.equals(problemplan) ); 11

31 Let s strip out the boilerplate! Why do we have to say we re supplying a Predicate? Why do we have to say we re implementing test, the only abstract method? planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) p {-> return p.equals(problemplan) ); planlist.removeif(p -> p.equals(problemplan)); 11

32 Let s strip out the boilerplate! Why do we have to say we re supplying a Predicate? Why do we have to say we re implementing test, the only abstract method? planlist.removeif(new Predicate<Plan>(){ public boolean test(plan p) p {-> return p.equals(problemplan) ); planlist.removeif(p -> p.equals(problemplan)); Basically, lambdas are just better syntax! 11

33 Presentation Overview The Magic Ingredient Result: Better APIs Pipes and Filters More Finely-Grained APIs Result: More Parallelism 12

34 Pipes and Filters Venerable Unix tool-building pattern: ps -ef grep login cut -c 50- head and in Enterprise Integration Patterns 13

35 Pipes and Filters Advantages of this pattern 14

36 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head 14

37 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head no intermediate variables 14

38 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head no intermediate variables less (or no) intermediate storage 14

39 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head no intermediate variables less (or no) intermediate storage lazy evaluation 14

40 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head no intermediate variables less (or no) intermediate storage lazy evaluation flexible tool-building: 14

41 Pipes and Filters Advantages of this pattern ps -ef grep login cut -c 50- head no intermediate variables less (or no) intermediate storage lazy evaluation flexible tool-building: Write programs that do one thing well. Write programs to work together. 14

42 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); 15

43 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); IntermediateOp IntermediateOp TerminalOp Source Stream<Plan> Stream<Plan> Stream<Plan> 15

44 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); IntermediateOp IntermediateOp TerminalOp Source Stream<Plan> Stream<Plan> Stream<Plan> 15

45 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); IntermediateOp IntermediateOp TerminalOp Source Stream<Plan> Stream<Plan> Stream<Plan> 15

46 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); IntermediateOp IntermediateOp TerminalOp Source Stream<Plan> Stream<Plan> Stream<Plan> 15

47 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); IntermediateOp IntermediateOp TerminalOp Source Stream<Plan> Stream<Plan> Stream<Plan> 15

48 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp Stream<Plan> IntermediateOp Stream<Plan> TerminalOp 15

49 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp Stream<Plan> TerminalOp 15

50 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp Stream<Plan> TerminalOp Instance of Mapper<Plan,Plan> 15

51 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp FilterOp Stream<Plan> TerminalOp Instance of Mapper<Plan,Plan> 15

52 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp FilterOp l Stream<Plan> TerminalOp Instance of Mapper<Plan,Plan> 15

53 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp FilterOp l Stream<Plan> TerminalOp Instance of Mapper<Plan,Plan> Instance of Predicate<Plan> 15

54 Pipes & Filters in collection operations deadlinedplans.stream().map(p->checkplan(p)).filter(p->p!=null).findfirst(); Source Stream<Plan> IntermediateOp MapOp l Stream<Plan> IntermediateOp FilterOp l Stream<Plan> TerminalOp l Instance of Mapper<Plan,Plan> Instance of Predicate<Plan> 15

55 Write programs that do one thing well java.util.functions.mapper: public interface Mapper<T, R> { R map(t t); java.util.functions.predicate public interface Predicate<T> { boolean test(t t); 16

56 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)); 17 19

57 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)); Collection 17 19

58 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)); MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());... Collection 17 19

59 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)); Collection MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());

60 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p));.filter(p->p!=null()); Collection MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());

61 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p));.filter(p->p!=null()); Collection FilterStreamIterator(StreamIterator<Plan> upstream, Predicate pred) { public Plan next() { Plan p = upstream.next();... return pred.test(p)? p : next(); // assume upstream.hasnext() MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());

62 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p));.filter(p->p!=null()); Collection MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());... FilterStreamIterator(StreamIterator<Plan> upstream, Predicate pred) { public Plan next() { Plan p = upstream.next(); return pred.test(p)? p : next(); // assume upstream.hasnext()

63 What is a Stream? A sequence of values May be partially evaluated Execution of lazy operations sets the pipeline up: Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p));.filter(p->p!=null()); Collection MapStreamIterator(StreamIterator<Plan> upstream, Mapper m) {... Plan next() { return m.map(upstream.next());... FilterStreamIterator(StreamIterator<Plan> upstream, Predicate pred) { public Plan next() { Plan p = upstream.next(); return pred.test(p)? p : next(); // assume upstream.hasnext()... No evaluation yet! 17 19

64 Lazy and eager operations Execution of lazy operations (IntermediateOps) sets the pipeline up Execution of eager operations (TerminalOps) pulls data down the pipeline Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)).filter(p->p!=null); planstream.findfirst(); // stop after the first element Collection 18

65 Lazy and eager operations Execution of lazy operations (IntermediateOps) sets the pipeline up Execution of eager operations (TerminalOps) pulls data down the pipeline Stream<Plan> planstream = deadlinedplans.stream().map(p->prepareplan(p)).filter(p->p!=null); planstream.findfirst(); // stop after the first element Collection 18

66 Some Stream methods // get the plans longer than 15 minutes planstream.filter(p -> p.getduration().islongerthan(minutes(15))) // get the total duration of all the plans in a list planstream.map(p -> p.getduration()).reduce(duration.zero, (d1,d2) -> d1.plus(d2)) // each plan belongs to a task; map each task to a collection of its plans planstream.groupby(p -> p.gettask()) // get the first five plans planstream.limit(10) // get all but the first five plans planstream.skip(10) 19

67 Some Stream methods name returns interface used l signature filter Stream<T> lazy Predicate<T> T boolean map Stream<T> lazy Predicate<T> T boolean reduce T eager BinaryOperator<T> (T, T) boolean groupby Map<U,Collection<T>> eager Mapper<T,U> T U limit, skip Stream<T> lazy findfirst T eager Predicate<T> T boolean foreach void eager Block<T> T void sorted Stream<T> lazy Comparator<T> (T, T) boolean 20

68 Presentation Overview The Magic Ingredient Result: Better APIs Pipes and Filters More Finely-Grained APIs Result: More Parallelism 21

69 Making finer-grained APIs Sorting a list using Comparator: Collections.sort(planList, new Comparator<Plan>() { public int compare(plan p1, Plan p2) { return p1.gettask().compareto(p2.gettask()); The method compare must first extract the sort keys and then compare them 22

70 Making methods more precise Suppose instead we have a method that accepts and returns behaviours: Comparator<T> comparing(mapper<t,u> m); Much easier now to create custom Comparators: Comparator<Plan> bytask = Comparators.comparing(p -> gettask()); Comparator<Plan> Comparator<Plan> byduration bytask = Comparators.comparing(p -> p.gettask()); getduration()); 23

71 Composing fine-grained methods Mappers and Comparators can now be composed new Comparator method Collections.sort(planList, bytask.compose(byduration)); and now also planlist.sort(bytask.compose(byduration)); 24

72 Composing fine-grained methods Mappers and Comparators can now be composed new Comparator method Collections.sort(planList, bytask.compose(byduration)); and now also planlist.sort(bytask.compose(byduration)); Plan::getDuration 24

73 Composing fine-grained methods Mappers and Comparators can now be composed new Comparator method Collections.sort(planList, bytask.compose(byduration)); and now also planlist.sort(bytask.compose(byduration)); Plan::getTask Plan::getDuration 24

74 Presentation Overview The Magic Ingredient Result: Better APIs Result: More Parallelism 25

75 External Iteration Foreach loop: for (Plan plan : planlist) { plan.setsection(null); or, equivalently, for (Iterator<Plan> pitr = planlist.iterator(); pitr.hasnext(); ) { pitr.next().setsection(null); 26

76 External Iteration Foreach loop: for (Plan plan : planlist) { plan.setsection(null); or, equivalently, for (Iterator<Plan> pitr = planlist.iterator(); pitr.hasnext(); ) { pitr.next().setsection(null); Client controls the iteration 26

77 External Iteration Foreach loop: for (Plan plan : planlist) { plan.setsection(null); or, equivalently, for (Iterator<Plan> pitr = planlist.iterator(); pitr.hasnext(); ) { pitr.next().setsection(null); Client controls the iteration Loop is inherently sequential 26

78 External Iteration Foreach loop: for (Plan plan : planlist) { plan.setsection(null); or, equivalently, for (Iterator<Plan> pitr = planlist.iterator(); pitr.hasnext(); ) { pitr.next().setsection(null); Client controls the iteration Loop is inherently sequential client would have to manage parallelisation 26

79 Internal iteration Strategy: Supply behaviour to general library methods 27

80 Internal iteration Strategy: Supply behaviour to general library methods planlist.foreach(p -> p.setsection(null)) 27

81 Internal iteration Strategy: Supply behaviour to general library methods planlist.foreach(p -> p.setsection(null)) Much simpler interaction. And now the library controls the iteration: Can use its own iteration tactics: Parallelism, out-of-order execution, laziness 27

82 Example: ConcurrentHashMap ConcurrentHashMap.parallel(ForkJoinPool) - Returns a parallel view of the CHM - Methods: foreach, foreachentry, foreachkey, foreachvalue,... - Consider foreachvalue(concurrenthashmap.action<v> action) - Creates a new ForEachValueTask -subclass of ForkJoinTask -submits that to the ForkJoinPool - ForkJoinPool executes ForEachValueTask on one of its threads 28

83 ConcurrentHashMap.ForEachValueTask static final class ForEachValueTask<K,V> extends BulkTask<K,V,Void> { final Action<V> action; ForEachValueTask (ConcurrentHashMap<K,V> m, Action<V> action) { super(m); this.action = action; ForEachValueTask (BulkTask<K,V,?> p, int b, boolean split, Action<V> action) { super(p, b, split); this.action = public final void compute() { final Action<V> action = this.action; if (action == null) throw new Error(NullFunctionMessage); int b = batch(), c; while (b > 1 && baseindex!= baselimit) { do { while (!caspending(c = pending, c+1)); new ForEachValueTask<K,V>(this, b >>>= 1, true, action).fork(); Object v; while ((v = advance())!= null) action.apply((v)v); trycomplete(); 29

84 ConcurrentHashMap.ForEachValueTask static final class ForEachValueTask<K,V> extends BulkTask<K,V,Void> { final Action<V> action; ForEachValueTask (ConcurrentHashMap<K,V> m, Action<V> action) { super(m); this.action = action; ForEachValueTask (BulkTask<K,V,?> p, int b, boolean split, Action<V> action) { super(p, b, split); this.action = public final void compute() { final Action<V> action = this.action; if (action == null) throw new Error(NullFunctionMessage); int b = batch(), c; while (b > 1 && baseindex!= baselimit) { do { while (!caspending(c = pending, c+1)); new ForEachValueTask<K,V>(this, b >>>= 1, true, action).fork(); Object v; while ((v = advance())!= null) action.apply((v)v); trycomplete(); 29

85 ConcurrentHashMap.ForEachValueTask static final class ForEachValueTask<K,V> extends BulkTask<K,V,Void> { final Action<V> action; ForEachValueTask (ConcurrentHashMap<K,V> m, Action<V> action) { super(m); if (action == null) this.action = action; ForEachValueTask (BulkTask<K,V,?> int p, int b b, = boolean batch(), split, c; Action<V> action) { super(p, b, split); this.action = public final void compute() { final Action<V> action = this.action; if (action == null) throw new Error(NullFunctionMessage); int b = batch(), c; while (b > 1 && baseindex!= baselimit) { do { while Object (!caspending(c = v; pending, c+1)); new ForEachValueTask<K,V>(this, b >>>= 1, true, action).fork(); Object v; while ((v = advance())!= null) action.apply((v)v); trycomplete(); public final void compute() { final Action<V> action = this.action; throw new Error(NullFunctionMessage); while (b > 1 && baseindex!= baselimit) { do { while (!caspending(c = pending, c+1)); new ForEachValueTask<K,V>(this, b >>>= 1, true, action).fork(); while ((v = advance())!= null) action.apply((v)v); 29

86 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); 30

87 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); 30

88 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork 30

89 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork 30

90 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork 30

91 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork 30

92 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork 30

93 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork 30

94 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork 30

95 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork join 30

96 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork join join 30

97 Stream parallelisation Collection.parallel().filter(...).map(...).reduce(...); fork fork fork join join join 30

98 Conclusion Lambdas seem like a small syntactic change, but a big difference in the style of Java code set the library writers free to innovate encourage a functional coding style less mutability = more parallel-friendly 31

99 Conclusion Lambdas seem like a small syntactic change, but a big difference in the style of Java code set the library writers free to innovate encourage a functional coding style less mutability = more parallel-friendly 31

100 Resources 32

101 Resources 32

102 Resources

103 Q&A