Alex Miller

Presentations

Java Concurrency Idioms

This presentation will look at the many new additions in Java 5 and 6 for concurrent programming such as Atomics, Locks, synchronizers, and concurrent collections. In particular, we will be looking at common concurrency idioms around locking and access to shared state, thread coordination, thread pooling, and work execution. Each of these topics will be presented with code examples demonstrating common idioms and the usage of these new concurrency primitives.

Some topics we will cover in detail include: * Thread coordination with Thread.join(), CountdownLatch, and CyclicBarrier * Access to shared state with synchronized, volatile, Atomics, Lock, ReadWriteLock * Using Locks and Conditions to achieve more flexibility than synchronized and wait/notify * Concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList, and ConcurrentSkipListMap * Work execution with Queues, ThreadPools, and Executors

Java 7 Preview

Possible library and language changes for Java 7 have been in discussion since early 2007 and many things have been proposed. This talk will focus on those items that are most likely to be included and some of the more controversial language changes that might be included in a future release. For a comprehensive list of almost everything being considered, see http://tech.puredanger.com/java7.

Some examples of topics that will be discussed include: * Java Module System * NIO 2 (new NEW IO) * Swing Application Framework, Bean Binding, and Bean Validation * Date and Time API * Fork/Join framework * JMX 2.0

Java Concurrency Gotchas

Concurrency is hard. Java has a rich set of concurrency primitives but its still possible to shoot yourself in the foot. In fact, concurrency makes it substantially more likely that you'll shoot both your feet and possibly the guy next to you. This talk will cover some common concurrency gotchas in Java, how to detect them, and how to fix them.

Examples include: * what NOT to synchronize on * inconsistent locking * wait/notify dangers * deadlock * race conditions * visibility * safe publication * final fields

Actor Concurrency

As the number of cores in our servers increase, concurrent programming continues to rise in importance. Most concurrent programming today focuses on shared memory and concurrency control via locking. However, an alternative paradigm called actor-based concurrency has been rising in visibility with languages like Erlang and Scala. We'll look at how actor-based concurrency differs from shared memory programming and how it can be utilized in languages like Erlang, Scala, and Java.

This talk will look at: * Trends in hardware * The problems with shared state concurrency * What is actor concurrency? * Erlang as the primary example of actor concurrency * Actor success stories * Scala as an alternative * Java frameworks providing an alternative * Kilim * Actor Foundry * Jetlang * Actor's Guild * Pros and cons vs shared state concurrency

Ehcache Complete

Caching is a critical component of any data-centric application. The obvious benefit of caching is to reduce latency but the hidden benefit is that it gives you more control over how and when you move data around your system.

Ehcache is the leading open-source Java caching library, combining both a full feature set and top performance. This session will explore key cache features like eviction based on time and memory, overflow to disk, clustered caching, cache warming, write-through and write-behind caching, and events.

In addition, we'll discuss how to tune and optimize caching performance in a cluster. This includes techniques like concurrency, partitioning, locking, tuning hot sets, and more.

This session will provide code examples and demos of using Ehcache both in a single node and in a Terracotta cluster.

Collections Master Class

To write great code, you must read great code. Fortunately, finding great Java code is pretty easy - it's right there in your JDK distribution hiding in plain sight. In particular, the JDK collections library contains some of the best examples of how to write an API that can stand the test of time, implement data structures, and manage concurrency.

This session will examine source code for key collection classes like ConcurrentHashMap, ConcurrentSkipListMap, and CopyOnWriteArrayList with an eye for understanding and appreciating well-written Java code and what it can teach us.

This is a brains-on walk through the source code and will not include slides (although some pictures may be used for clarity). Familiarity with the Java Collections framework is recommended but not required.