Effective java item 80 and 81
0 likes141 views
This document discusses concurrency utilities in Java and recommends using executors, tasks, streams, concurrent collections, and synchronizers rather than raw threads and wait/notify. It provides examples of executor frameworks, ForkJoinPool, Runnable and Callable interfaces, concurrent collections like ConcurrentHashMap, and synchronizers like CountDownLatch, Semaphore, and Exchanger. The document also discusses String interning and how it can be implemented using ConcurrentHashMap's putIfAbsent method.
More Related Content
What's hot (20)
Similar to Effective java item 80 and 81 (20)
More from Isaac Liao (8)
Recently uploaded (20)
Effective java item 80 and 81
- 1. Effective Java Item 80: Prefer executors, tasks, and streams to threads Item 81: Prefer concurrency utilities to wait and notify
- 2. Item 80 Prefer executors, tasks, and streams to threads
- 3. Executor Framework - Basic Example ● Submit a runnable for execution ExecutorService exec = Executors.newSingleThreadExecutor(); exec.execute(runnable); exec.shutdown();
- 4. Executor Framework - invokeAny - Wait until first done
- 5. Executor Framework - invokeAny - Wait until ALL done
- 6. Executor Framework - invokeAny - Wait until ALL done ● Hard to get future result by complete sequence
- 7. Executor Framework - ExecutorCompletionService ● Get future result by sequence
- 8. Executor Framework - Cancel rest jobs
- 9. Executor Framework - Schedule task
- 10. Executor Framework - Choose executor ● Executors.newCachedThreadPool ○ Easy, no configuration ○ Do the right thing ○ When no available thread, new one will be added to pool ○ No task will be queued ○ Choose for small program ■ Why not heavy load program?
- 11. Executor Framework - Choose executor ● Executors.newCachedThreadPool ○ Easy, no configuration ○ Do the right thing ○ When no available thread, new one will be added to pool ○ No task will be queued ○ Choose for small program ■ Why not heavy load program? ● all of CPUs are fully utilized ● more tasks arrive, more threads will be created ● less CPU available, cause matters worse
- 12. Executor Framework - Choose executor ● Executors.newFixedThreadPool ○ Gives a pool with fixed number of threads ○ For heavy load program ○ Still need monitor queue size
- 13. Runnable & Callable ● Runnable: no return value ● Callable: return value
- 14. ForkJoinPool ● Normal Executor Thread Management ○ Main thread put task to queue ○ Sub tasks put tasks to queue ○ Every task in a queue without boundry Main Time
- 15. ForkJoinPool ● ForkJoinPool Thread Management ○ Main thread create tasks ○ Tasks create sub tasks to fork ○ tasks wait for sub tasks to join ○ Main thread get result or wait for done Time task1 Main task1-1 task1-2 task2 task2-1 task2-2 Time
- 17. Item 81 Prefer concurrency utilities to wait and notify
- 18. It’s difficult “Given the difficulity of using wait and notify correctly, you should use the higher-level concurrency utilities instead”
- 19. Related Topics ● Executor Framework - Item 80 ● Concurrent collections - Item 81 ● Synchronizers - Item 81
- 20. Concurrent collections ● They are high-performance concurrent implementation of standard collection interfaces. ● Each implementations need manage their own synchronization internally. ● It is impossible to exclude concurrent activity from a concurrent collection ● locking it will only slow the program
- 21. Compose method invocations ● You can’t exclude concurrent activity on concurrent collections (will become slow), you can’t automatically compose method invocations on them either. ● So concurrent collection interfaces were outfitted with state-dependent modify operations, combine several primitives into a single atomic operation. Ex. Map.putIfAbsent(key, value)
- 22. String#intern String#intern will find string from cache before creating new instance. String s1 = “test”; String s2 = new String(“test”); String s3 = new String(“test”).intern(); System.out.println(s1 == s2); // false System.out.println(s1 == s3); // true
- 23. String#intern implementation by putIfAbsent private static final ConcurrentMap<String,String> map = new ConcurrentHashMap<>(); public static String intern(String s) { String pre = map.putIfAbsent(s, s); return pre == null ? s : pre; }
- 24. String#intern implemented by ConcurrentHashMap ConcurrentHashMap is optimized for retrieval operations, such as get. public static String intern(String s) { String result = map.get(s); if (result == null) { result = map.putIfAbsent(s, s); if (result == null) { result = s; } } return result; }
- 25. ConcurrentHashMap is high performance Replace Collections.synchronizedMap by new ConcurrentHashMap can dramatically increase performance.
- 26. BlockingQueue ● take method will wait until queue is not empty
- 27. Synchronizer ● Enable threads to wait for one another ● Ex. CountDownLatch: Wait until count down to zero ● Ex. Semaphore: Wait until token available ● Ex. CylicBarrier: Wait until all are waiting ● Ex. Exchanger: Wait until another thread is ready ● Ex. Phaser: Wait until other arrived
- 28. Legacy ● Always use the wait loop idiom to invoke the wait method, never invoke it outside of a loop synchronized (obj) { while (<condition>) { obj.wait(); } }