Status Updates From Java Concurrency in Practice

Already making me realize how carelessly I have constructed classes in the past. Competent writing so far. high hopes given I have nothing but respect for Joshua Bloch. I treat his "Effective Java" book as scripture and reference it all the time.

Chapter 16 - One of these days, I should read the actual Java memory model. But in the meantime, having a nice summary was helpful.

Chapter 15 - The lock-free queue algorithm presented here was fascinating.

Chapter 14 - I already understood condition variables, but it was interesting to see how they work in Java. The AbstractQueuedSynchronizer was new to me. I don't think I could use it solely based on the info in this book, though.

Chapter 13 - I didn't really understand explicit Lock objects in Java before. Good to know, I guess. Although honestly I really love Java's synchronized keyword.

Chapter 12 - Lots of great advice here!

A lot of this was stuff I knew or common sense. Still, I have a feeling I'll be coming back to this chapter if I'm ever seriously trying to improve the performance of a concurrent program.

Chapter 10 - Interesting contrast of Java with database systems. I usually take it for granted that deadlock will be unrecoverable, but it's a good point that there are real world systems that very often recover! The pattern of "open calls" also sounds very useful and is not something I had considered before.

Chapter 9 - "If you've tried to write even a simple GUI application using Swing..." No, I haven't. Maybe I should have skipped this chapter.

Chapter 8 - Very interesting, although not as relevant if you're used to working with higher level third party execution frameworks instead of managing your own thread pools.

Chapter 7 - I've spent surprisingly little time in my career making sure the programs I write are responsive to cancellation. Still, it's interesting to know the intention behind InterruptedException. I have to wonder about the design choice, though, since it forces every program to handle InterruptedException even though many might not care about supporting cancellation. What a pain.

Chapter 6 - This is a very useful chapter. ExecutorService is a must have for concurrent code, and the chapter clearly explains why.

Chapter 5 - This chapter is interesting, but I can't remember the last time I used a Semaphore in Java, let alone a Latch or a Barrier. Futures, on the other hand, I use all the time.

Chapter 4 - Solid, practical chapter. The contents are a lot more intuitive to me than chapter 3, though. I didn't learn as much.

To me, the need for safe publication is one of the least intuitive parts of concurrency in Java. I didn't even understand what safe publication was, let alone why I needed it or how to achieve it, before reading this book.

Visibility concerns are a lot less intuitive to me than a need for atomicity. It's hard to remember now, but I'm pretty sure I used to think that if only one thread writes to a variable, and all writes are single step (so the data is never in an inconsistent state, even temporarily), no synchronization is needed. But the variable needs to be volatile if no locking is used. This book has really hammered that home.

Chapter 2 - I love this chapter! It is really concurrency basics that could apply to most languages, but laid out so clearly.

"It is a common mistake to assume that synchronization needs to be used only when writing to shared variables" - can confirm. I definitely know better, but I have still forgotten before.

Haha, you don't have to convince me concurrency is useful and hard. I am sold!

I started this one before and failed to finish it. After scratching my head over some concurrent code today, I think it's time to pick it back up.

It is a good book for understanding for java conccurency in practice. I recognize new things and learned them applying.

learned a lot!

Amazing read!

Explicit Locks

Testing Concurrent Programs

Amdahl's Law

Performance & scalability

Part II: Structuring Concurrent Applications

Delegating Thread Safety

Sharing objects