Java Collections The Force Awakens.

Transcription

1 Java Collections The Force Awakens

2

3 Collection Problems Java Episode 8 & 9 Persistent & Immutable Collections HashMaps

4 Collection bugs Element access (Off-by-one error, ArrayOutOfBound) Concurrent modification Check-then-Act

5 Scenario 1 List<String> jedis = new ArrayList<>(asList("Luke", "yoda")); for (String jedi: jedis) { if (Character.isLowerCase(jedi.charAt(0))) { jedis.remove(jedi); } }

6 Scenario 2 Map<String, BigDecimal> movieviews = new HashMap<>(); BigDecimal views = movieviews.get(movie); if(views!= null) { movieviews.put(movie, views.add(bigdecimal.one)); } Then moviesviews.get views!= null Check movieviews.put Act

7 Reducing scope for bugs ~280 bugs in 28 projects including Cassandra, Lucene ~80% check-then-act bugs discovered are put-if-absent Library designers can help by updating APIs as new idioms emerge Different data structures can provide alternatives by restricting reads & updates to reduce scope for bugs CHECK-THEN-ACT Misuse of Java Concurrent Collections

8 Collection Problems Java Episode 8 & 9 Persistent & Immutable Collections HashMaps

9 Java 8 Lazy Collection Initialization Many allocated HashMaps and ArrayLists never written to, eg Null object pattern Java 8 adds Lazy Initialization for the default initialization case Typically 1-2% reduction in memory consumption et=28&page=0

10

11 Java 9 API updates Collection factory methods Non-goal to provide persistent immutable collections java.util.optional ifpresentorelse(), or(), stream(), getwhenpresent() Optional.get() will be deprecated in future java.util.stream & java.util.stream.collectors takewhile, dropwhile filtering, flatmapping java.util.concurrent.completablefuture ortimeout, completeontimeout

12 Collection Problems Java Episode 8 & 9 Persistent & Immutable Collections HashMaps

13 Categorising Collections Mutable Unsynchronized Concurrent Available in Core Library Unmodifiable View Immutable Non-Persistent Persistent

14 Mutable Popular friends include ArrayList, HashMap, TreeSet Memory-efficient modification operations State can be accidentally modified Can be thread-safe, but requires careful design

15 Unmodifiable List<String> jedis = new ArrayList<>(); jedis.add("luke Skywalker"); List<String> cantchangeme = Collections.unmodifiableList(jedis); // java.lang.unsupportedoperationexception //cantchangeme.add("darth Vader"); System.out.println(cantChangeMe); // [Luke Skywalker] jedis.add("darth Vader"); System.out.println(cantChangeMe); // [Luke Skywalker, Darth Vader]

16

17 Immutable & Non-persistent No updates Flexibility to convert source in a more efficient representation No locking in context of concurrency Satisfies co-variant subtyping requirements Can be copied with modifications to create a new version (can be expensive)

18 Immutable vs. Mutable hierarchy java.util.list ListIterable ImmutableList + MutableList<T> tolist() MutableList + ImmutableList<T> toimmutable() Eclipse Collections (formaly GSCollections)

19 Immutable and Persistent Changing source produces a new (version) of the collection Resulting collections shares structure with source to avoid full copying on updates

20 Persistent List (aka Cons) public final class Cons<T> implements ConsList<T> { private final T head; private final ConsList<T> tail; public Cons(T head, ConsList<T> tail) { this.head = head; this.tail = tail; public ConsList<T> add(t e) { return new Cons(e, this); } }

21 Updating Persistent List Before A B C X Y Z

22 Updating Persistent List Before A B C B D X Y Z After A Blue nodes indicate new copies Purple nodes indicates nodes we wish to update

23 Concatenating Two Persistent Lists Before A B C X Y Z

24 Concatenating Two Persistent Lists Before - After A B C X Y Z A Poor locality due to pointer chasing Copying of nodes B C

25 Persistent List Structural sharing: no need to copy full structure Poor locality due to pointer chasing Copying becomes more expensive with larger lists Poor Random Access and thus Data Decomposition

26 Updating Persistent Binary Tree Before

27 Updating Persistent Binary Tree After

28 Persistent Array How do we get the immutability benefits with performance of mutable variants?

29 Trie 1. Branch factor not limited to binary root a c b a 20 b 10 c e f Picking the right branch is done by using parts of the key as a lookup 2. Leaf nodes contain actual values

30 Persistent Array (Bitmapped Vector Trie) Level 1 (root) Level Leaf nodes

31 Trade-offs Large branching factor facilitates iteration but hinders updates Small branching factor facilitates updates but hinders traversal

32 Java Persistent Collections - Not available as part of Java Core Library - Existing projects includes - PCollections: - Port of Clojure DS: - Port of Scala DS: - Coming soon to Javaslang

33 Memory usage survey 10,000,000 elements, heap < 32GB int[] : 40MB Integer[]: 160MB ArrayList<Integer>: 215MB PersistentVector<Integer>: 214MB (Clojure-DS) Vector<Integer>: 206MB (Dexx, port of Scala-DS) Data collected using Java Object Layout:

34 Primitive specialised collections Collections often hold boxed representations of primitive values Java 8 introduced IntStream, LongStream, DoubleStream and primitive specialised functional interfaces Other libraries, eg: Agrona, Koloboke and Eclipse-Collections provide primitive specialised collections today. Valhalla investigates primitive specialised generics

35 Takeaways Immutable collections reduce the scope for bugs Always a compromise between programming safety and performance Performance of persistent data structure is improving

36 Collection Problems Java Episode 8 & 9 Persistent & Immutable Collections HashMaps

37

38 HashMaps Basics Han Solo hash = Chewbacca hash =

39 HashMaps Chaining a separate data structure for collision lookups Probing Store inline and have a probing sequence

40 Aliases: Palpatine vs Darth Sidious

41 HashMaps Chaining Probing aka Closed Addressing aka Open Addressing aka Open Hashing aka Closed Hashing

42 HashMaps Chaining Linked List Based Probing Tree Based

43 java.util.hashmap Chaining Based HashMap Historically maintained a LinkedList in the case of a collision Problem: with high collision rates that the HashMap approaches O(N) lookup

44 java.util.hashmap in Java 8 Starts by using a List to store colliding values. Trees used when there are over 8 elements Tree based nodes use about twice the memory Make heavy collision lookup case O(log(N)) rather than O(N) Relies on keys being Comparable

45 So which HashMap is best?

46 Benchmarking is about building a mental model of the performance tradeoffs

47 Example Jar-Jar Benchmark call get() on a single value for a map of size 1 No model of the different factors that affect things!

48 Benchmarking HashMaps Load Factor Nonlinear key access Successful vs Failed get() Hash Collisions Comparable vs Incomparable keys Different Keys and Values Cost of hashcode/equals

49 Tree Optimization - 60% Collisions

50 Tree Optimization - 10% Collisions

51 Probing vs Chaining Probing Maps usually have lower memory consumption Small Maps: Probing never has long clusters, can be up to 91% faster. In large maps with high collision rates, probing scales poorly and can be significantly slower.

52 Takeaways There s no clearcut winner. JDK Implementations try to minimise worst case. Linear Probing requires a good hashcode() distribution, Often hashmaps precondition their hashes. IdentityHashMap has low memory consumption and is fast, use it! 3rd Party libraries offer probing HashMaps, eg Koloboke & Eclipse-Collections.

53 Conclusions

54 Interface Popularity List Set Map Queue Deque 3464 SortedSet 9121 NavigableSet 1735 SortedMap 8677 NavigableMap 1484

55 Implementation Popularity ArrayList LinkedList ArrayDeque 1086 HashSet TreeSet EnumSet HashMap TreeMap 7734 WeakHashMap 3473 IdentityHashMap 2443 EnumMap 1904

56 Java 1.2 Evolution can be interesting... Java 10?

57

58 Any Questions? Modern Development with Java 8 Reactive and Asynchronous Java Java Software Development Bootcamp

59 Further reading Fast Functional Lists, Hash-Lists, Deques and Variable Length Arrays Smaller Footprint for Java Collections Optimizing Hash-Array Mapped Tries for Fast and Lean Immutable JVM Collections RRB-Trees: Efficient Immutable Vectors

60 Further reading Doug Lea s Analysis of the HashMap implementation tradeoffs Java Specialists HashMap article Sample and Benchmark Code

61 Further reading Debian code search used for popularity

62 Small HashMaps Many HashMaps are small or empty Lazy Initialization In Java 8+ Specialised Implementations Collections.singleton*/Collections.empty* Collectors.partitioningBy() Specialised Eclipse Collections (eg Doubleton)

63 Probing Sequence Linear - Cache Locality Quadratic - Tree Clever ideas

64 Implementing Persistent Collections Fat node Nodes store updated values in an internal list Different versions accessible using an order (e.g. timestamp) Path copying Copy path leading to updated node Share rest with previous version

65 Benchmarking HashMaps Test different Assumptions + Behaviours Understand costs, don t just measure them Be Scientific Use a framework Peer Review - Wisedom of crowds

66 Preconditioning h = key.hashcode() ^ (h >>> 16);

67 CopyOnWrite public boolean add(e e) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] elements = getarray(); int len = elements.length; Object[] newelements = Arrays.copyOf(elements, len + 1); newelements[len] = e; setarray(newelements); return true; } finally { lock.unlock(); } }

68 Persistent Array (Bitmapped Vector Trie) Uses bit pattern (representing index number) for efficient arithmetic / lookup of elements Branching factor of 32 and depth of 5 can stores 33 millions elements and requires 5 lookups to find an element practically constant