In this episode we talk about Threads and Threading, the difference between Daemon and User Threads, and why changing priorities is not for the weak of heart. Also we cover Swing's golden Threading rule (with the Event Dispatching Thread). If you ever typed new Thread(), or if you heard to be careful about Swing and Threading, this episode is for you!

In this week's podcast we talk about Design Patterns (and the Grand Dads of the Software Patterns, the Gang-of-four), and dive into our first design pattern (of many), the Observer pattern. We discussed how to implemented (within Java), and went to describe its use in Java Swing, and why anonymous inner classes for Listeners doesn't create memory leaks (most of the time anyways). In all a great introduction to a first pattern (see what they are all about!)

In this podcast we dive into the age-old producer and consumer problem, talked about the different aspects of it (what does it really solve?), and explain the difference between throughput vs latency. Lastly we discuss the ThreadPoolExecutor and how to fine tune it for your particular project needs!

In this episode we describe the most used collections in the Java framework, and how can they help you out. We also talk about maps (and the importance of immutable keys), and the equals/hashcode contract (why are these anyways? :). Finally we discuss how to safely access these collections/maps from different threads (and cover the check-then-act operations in maps). If you used a map, or ever got a ConcurrentModificationException, this episode is for you!

This episode goes deep into memory in Java, understanding how memory leaks happen (and how to solve them!), also how to design to avoid memory leaks, weak and soft references, and how the Garbage collector works (Eden, Tenured, Perm). This podcast will help everyone that needs to take care of a memory leak!

Kudos to VisualVM and VisualGC!

In this episode of Java pub house, we talk about Deadlocks, livelocks (and other spooky things). Most importantly we talk on how to spot them (using jstack, or visualvm), and how to program defensively against them. We also talk about escaped locks (the source of most deadlocks), and the wait/notify language construct. Finally we describe the unfairness of the lock (locks are not "fair" by default), and why is it so.

On this Episode, we talk about the keyword "volatile", and what does it really mean. Even if you are a multithreading guru, this chapter goes in deep of the different things that volatile protects you from, including L2 caches and code re-ordering. We also cover the use of synchronized, and why, even though is convenient, it might create more headache than it actually solves.