"synchronized" is obsolete

The "synchronized" keyword in Java allows defining critical sections of code, where shared resources must only be accessed by one thread at a time.

Since Java 5, several alternative ways of handling shared resources have sprung up, such as atomic references and map operations, backed by modern CAS operations in modern hardware.

But ultimately, new deployment environments such as kubernetes which achieve resiliency by having redundant load-balanced processes, have render this keyword obsolete, since the lock provided by it is only effective inside one JVM process.

Transcript

1. ⛔ Enrique Zamudio @chochosmx synchronized
2. Who? •Been programming for 25 years •19 of those spent on Java •Named Java Champion in 2015 •Doing backend development since 2004
3. synchronized "To handle concurrency"
4. foo() { ... } foo() { ... } foo() { ... }
5. synchronized(this) { ... } foo() { ... } foo() { ... } foo() { ... }
6. synchronized "To handle concurrency" ❌
7. volatile int sharedCounter; synchronized(lock) { sharedCounter++; } BigDecimal sharedTotal; synchronized(lock) { sharedTotal = sharedTotal .add(1.0); }
8. AtomicInteger sharedCounter; sharedCounter.incrementAndGet(); sharedCounter.compareAndSet(100, 1); AtomicReference<BigDecimal> sharedTotal; sharedTotal.updateAndGet(d -> d.add(1.0));
9. Map<String, List<?>> map; synchronized(this) { List<?> list = map.get(key); if (list == null) { list = new ArrayList<>(); map.put(key, list); } list.add(element); }
10. ConcurrentHashMap<String,List<?>> map; map.computeIfAbsent(key, k -> new ArrayList<>() ).add(element);
11. Map<String, BigDecimal> map; synchronized(this) { BigDecimal num = map.get(key); if (num == null) { num = new BigDecimal.ZERO; } num = num.add(value); map.put(key, num); }
12. ConcurrentHashMap<String, BigDecimal> map; map.merge(key, value, BigDecimal::add);
13. Other collections from Java 5 • ConcurrentSkipListMap • ConcurrentSkipListSet • LinkedBlockingQueue
14. LinkedBlockingQueue • Can take elements concurrently • Can deliver elements concurrently • Blocks calling thread when empty • Unblocks consumers as soon as there's something in it • Every element is delivered to exactly one consumer
15. Thread pools
16. Thread pool Worker thread 1 Worker thread 2 Worker thread 3 Worker thread 4 Worker thread 5 Worker thread 6 Task Task Task Task Task Task Task Task Task Task Task Task Task Task Task
17. Thread pool Task Task Task Task Task Task Task Task Task Task Task Task Task Task Task Runnable Callable Future
18. Locks • Lock • ReadWriteLock • ReentrantLock • CountDownLatch • CyclicBarrier • Semaphore • Phaser
19. Lock • lock() • tryLock() • tryLock(10, SECONDS) • unlock()
20. Other wonderful things • Akka • vert.x • Project Loom
21. Account acct = getAccount(); synchronized (this) { updateBalance(acct, amt); }
22. But then...
23. my-service.jar
24. my-service.jar my-service.jar my-service.jar {
25. my-service.jar my-service.jar my-service.jar { synchronized (lock) { .... } synchronized (lock) { .... } synchronized (lock) { .... }
26. my-service.jar my-service.jar my-service.jar { synchronized (lock) { .... } synchronized (lock) { .... } synchronized (lock) { .... }
27. my-service.jar my-service.jar my-service.jar {
28. SELECT ... FOR UPDATE
29. SET lock_name <random value> NX PX 30000 if (value.equals(redis.get(lock_name)) { redis.del(lock_name); } else { //lock is held by someone else }
30. FencedLock • Developed by Hazelcast • Implements java.util.concurrent.locks.Lock interface • Raft consensus algorithm • Reentrant by default, but configurable
31. DeadLock • Always acquire locks in the same order • Particularly tricky with DB locks
32. ¿?
33. ¡Gracias! @chochosmx