Java Concurrency (&c)

Scala / Java Shootout

2011-06-03T08:14:00.000-07:00

I should probably comment on this paper from my colleague Robert Hundt, where he writes the same benchmark in Java, Scala, Go, Python and C++ (TL;DR here). Short version: Initially, C++ was faster than Scala, and Scala was faster than Java. I volunteered to make some improvements, which ended up with the C++ and Java implementations being about the same speed. Some C++ hackers then went and

Java Puzzlers@Google I/O

2011-05-13T09:40:00.000-07:00

Josh Bloch and I gave one of his Java Puzzlers talk at Google I/O this year. If you hate Java, you can waste a perfectly good hour listening to us make unfunny jokes at its expense.

Cliff Click in "A JVM Does What?"

2011-04-05T16:25:00.000-07:00

Cliff Click gave a very good talk at Google last week. For your viewing enjoyment:The slides are available here.(For those who watched it: The inventors of bytecode were in the audience. I think he was just used to making that joke elsewhere.)

JavaOne Talk Cancelled

2010-08-27T12:31:00.000-07:00

Because I am a Google employee, my talks are not happening. Apologies to any interested parties.I'm going to try to give the talks in another venue, or at least to use the blog as a venue for some of the topics I wanted to cover.

Why Many Profilers have Serious Problems (More on Profiling with Signals)

2010-08-02T00:07:00.000-07:00

This is a followon to a blog post I made in 2007 about using signal handling to profile Java apps. I mentioned in another post why this might be a good idea, but I wanted to expand on the theme.Hiroshi Yamauchi and I are giving a talk at this year's JavaOne. Part of this talk will be about our experiences writing profilers at Google, and in preparing for it, I realized my previous entry on this

Garbage Collection, [Soft]References, Finalizers and the Memory Model (Part 2)

2010-02-07T23:56:00.000-08:00

In which I ramble on at greater length about finalizers and multithreading, as well as applying that discussion to SoftReferences. Read Part 1 first. It explains why finalizers are more multithreaded than you think, and why they, like all multithreaded code, aren't necessarily going to do what you think they should do.I mentioned in the last entry that a co-worker asked me a question about when

Garbage Collection, References, Finalizers and the Memory Model (Part 1)

2010-01-31T23:39:00.000-08:00

A little while ago, I got asked a question about when an object is allowed to be collected. It turns out that objects can be collected sooner than you think. In this entry, I'll talk a little about that.When we were formulating the memory model, this question came up with finalizers. Finalizers run in separate threads (usually they run in a dedicated finalizer thread). As a result, we had to

A Note on the Thread (Un)safety of Format Classes

2010-01-06T20:40:00.000-08:00

I recently got a note on another blog post asking this question:I have a general question on the thread safety and this is not directly related with your blog. I would appreciate if you could post it on your blog. I have a class that has only one static method that accepts two string parameters and does some operation locally (as shown below). Do I need to synchronize this method?public class A {

Allocation Instrumenter for Java

2009-12-10T15:52:00.001-08:00

In brief: We've open sourced a tool that allows you to provide a callback every time your program performs an allocation. The Java Allocation Instrumenter can be found here. Give it a whirl, if you are interested.One thing that crops up a lot at my employer is the need to take an action on every allocation. This can happen in a lot of different contexts:The programmer has a task, and wants to

Cliff Click on Java-vs-C Performance

2009-09-07T22:56:00.000-07:00

Cliff Click has a terrific post on Java-vs-native-code performance. Recommended.Cliff is the Chief JVM Architect at Azul Systems, was the lead designer behind Hotspot's server JIT compiler, and is an all-around smart guy. His main drawback is that he (apparently) gets dragged into flamewars on YouTube's comment section.

How Hotspot Decides to Clear SoftReferences

2009-07-07T23:23:00.000-07:00

I got asked about this twice in one day, and I didn't know the answer, so I sat down and puzzled it out a bit.A SoftReference is a reference that the garbage collector can decide to clear if it is the only reference left to an object, and the GC decides (through some undefined process) that there is enough memory pressure to warrant clearing it. SoftReferences are generally used to implement

Volatile Arrays in Java

2009-06-17T10:30:00.000-07:00

I get asked a lot about how the volatile keyword interacts with arrays, so it is probably worth a blog post on the subject.Those of you who have read my posts on volatile (Volatile Fields and Synchronization, Volatile Does Not Mean Atomic and, most importantly, What Volatile Means in Java) will have a pretty good idea of what volatile means, but it is probably worth it to provide a reminder.

Welcome!

2009-06-09T00:38:00.000-07:00

Mailinator's Paul Tyma linked to me. If you are following from that link, the relevant blog entry you are looking for is probably this one, specifically, the entry labeled "visibility".

Faster Logging with Faster Logger Classes

2009-04-04T13:56:00.000-07:00

Today, I'll discuss a little tweak I made to java.util.Logging that made my logging throughput double. I want to use it as an illustration that it often isn't very difficult to improve the performance of concurrent code by doing things that are actually pretty easy to do.So, "I" have an application that is running a couple of hundred threads on an 8-core machine, and it wants to log about 2MB a

Small Language Changes for JDK7

2009-02-28T16:25:00.001-08:00

For those who haven't been paying attention, there is a new project from Sun to attract proposals for small language changes to JDK7. Even in the first day of open calls for proposals, the entries have been very interesting:Strings in Switch, a proposal from Joe Darcy to be able to use Strings in switch statements.Automated Resource Blocks, a proposal from Josh Bloch to be able to say things

Date-Race-Ful Lazy Initialization for Performance

2008-12-14T11:49:00.000-08:00

I was asked a question about benign data races in Java this week, so I thought I would take the opportunity to discuss one of the (only) approved patterns for benign races. So, at the risk of encouraging bad behavior (don't use data races in your code!), I will discuss the canonical example of "benign races for performance improvement". Also, I'll put in another plug for Josh Bloch's new

What Volatile Means in Java

2008-11-15T13:05:00.000-08:00

Today, I'm going to talk about what volatile means in Java. I've sort-of covered this in other posts, such as my posting on the ++ operator, my post on double-checked locking and the like, but I've never really addressed it directly.First, you have to understand a little something about the Java memory model. I've struggled a bit over the years to explain it briefly and well. As of today, the

G1 Garbage Collector in Latest OpenJDK Drop

2008-11-08T23:50:00.000-08:00

ETA: The G1 collector is now in the latest JDK6 release, which you can download from Sun here. You can enable it for testing with the flags -XX:+UnlockExperimentalVMOptions -XX:+UseG1GC. Original post follows.For those of you who are interested in tinkering with new garbage collectors, the "Garbage-first" G1 garbage collector is in the new JDK7 drop from OpenJDK. I haven't tried it yet, but I

A Brief Digression into Politics

2008-10-26T23:49:00.000-07:00

A plea for you to vote "No" on CA Proposition 8, and maintain the rights of same-sex couples in California.I really hate using this blog as a political forum. I have a personal blog I use for that, read only by people who know me. This blog should be expressly for computer-related topics. I apologize to readers expecting me to talk about concurrency or APIs or anything else. I apologize to

Don't Use StringBuffer!

2008-08-24T01:30:00.000-07:00

One thing I have noticed among Java API users is that some don't seem to know that there is a difference between StringBuffer and StringBuilder. There is: StringBuffer is synchronized, and StringBuilder isn't. (The same is true for Vector and ArrayList, as well as Hashtable and HashMap). StringBuilder avoids extra locking operations, and therefore you should use it where possible. That's not

Top 3 Reasons Why Constructors are Worthless

2008-08-18T00:46:00.000-07:00

In my last post, I made an offhand reference to the fact that object constructors are worthless in Java. I was asked why this is, so I thought I'd fill in the details.This topic is a little more well-understood by the developer community than some of the concurrency tidbits that I usually discuss. People who use dependency injection toolkits like Guice and Spring's inversion of control tend to

Immutability in Java, Part 3: Deserialization and Reflection

2008-07-21T00:26:00.000-07:00

This time, I'll talk about deserialization, immutability and final fields. I'll try to be a little shorter.I spent the last two posts on immutability (here and here) talking about what it takes to make an object's fields immutable. This advice mostly boiled down to "it has to be final and set before the constructor ends".When you have deserialization, though, the fields can't be set before the

Immutability in Java, Part 2

2008-07-14T00:01:00.000-07:00

I'd like to talk a little more about what it takes to ensure thread-safe immutability in Java, following on from a (semi)recent post I made on the subject.The basic gist of that post was that if you make data immutable, then they can be shared between threads without additional synchronization. I call this "thread-safe immutability". In that post, I said this:Now, in common parlance,

Double Checked Locking

2008-05-23T00:53:00.000-07:00

I still get a lot of questions about whether double-checked locking works in Java, and I should probably post something to clear it up. And I'll plug Josh Bloch's new book, too.Double Checked Locking is this idiom: // Broken -- Do Not Use! class Foo { private Helper helper = null; public Helper getHelper() { if (helper == null) { synchronized(this) { if (helper == null) {

Which Lock is Which?

2008-05-11T23:29:00.000-07:00

I was at JavaOne last week, and attended Bill Pugh's Defective Java talk. Bill had an important point about what kind of locks you want to be using and what kind you don't, and that point is worth repeating.Bill is, with Dave Hovemeyer, the guy behind FindBugs, which everyone should be using religiously. He was also my graduate advisor; we worked together on the new Java Memory Model. If there

Immutability in Java

2008-04-25T22:15:00.001-07:00

Another topic that comes up again and again in questions that people ask me is, "How does immutability work in Java"? Immutability is a godsend for concurrent programmers, because you don't have to do lots of sticky reasoning about what threads are updating what variables when, and you don't have to worry about cache thrashing, and you don't have to worry about all sorts of things. When I write

Talk on x86 Memory Model

2008-03-06T22:55:00.000-08:00

Rick Hudson gave a talk at Google about the new official memory model for the Intel x86 platform. Good stuff, for memory model geeks.

Java Performance Talk

2008-03-05T23:35:00.000-08:00

Paul Tyma and I gave a talk at SD West today on Java Performance Myths. The big takeaway was this: Most of the things you think you know about Java performance are really hard to quantify. Write the best code you can. Profile it to find the bottlenecks. Remove the bottlenecks. Rinse and repeat.A couple of other takeaway points here:Don't forget to upgrade every so often. JDK6, for example,

Hotspot Garbage Collection

2008-03-05T09:35:00.000-08:00

Thought of the Day: The production version of Hotspot has 211 command line options for garbage collection. Getting the right combination of options is hard.

Causality and the Java Memory Model

2008-02-12T13:47:00.000-08:00

NB: I started writing this last August, and sent it to a friend of mine for thoughts. I just realized that he never got back to me on it, and I never posted it. I don't much feel like editing it now, so here it is in its original gloryOkay, I know. It is nearly impossible to read and understand the causality bits of the Java memory model. That's all that stuff about "Executions and Causality

Atomicity, Visibility and Ordering

2007-08-30T23:35:00.000-07:00

(Note: I've cribbed this from my doctoral dissertation. I tried to edit it heavily to ease up on the mangled academic syntax required by thesis committees, but I may have missed some / badly edited in places. Let me know if there is something confusingly written or just plain confusing, and I'll try to untangle it.)There are these three concepts, you see. And they are fundamental to correct

Volatile Does Not Mean Atomic!

2007-08-21T16:16:00.001-07:00

Here's a question I get a lot. Is the following code snippet "thread safe"?volatile int v = 0;Thread 1:v++;Thread 2:v--;The question asks what the possible results of this code are; the questioners usually want the answer "v can only be 0 after this code is run".This isn't the way it works! If you do an increment of a volatile integer, you are actually performing three separate operations:Read

Java Puzzlers at Google

2007-08-14T00:49:00.000-07:00

Those of you who attend JavaOne will know Josh Bloch, Neal Gafter and Bill Pugh's series of highly entertaining Java Puzzlers. Now, for the first time, one of these talks is available to people who are not JavaOne attendees: Josh and Bill gave this year's Java Puzzlers talk at Google.I wouldn't dare spoil the fun by posting any of the puzzlers or their solutions (although Josh blows the surprise

Mark Moir on Transactional Memory

2007-08-01T21:18:00.001-07:00

This is another one of those Google talks. This time, it is Mark Moir talking about the transactional memory work he is doing at Sun. It is very useful if you are interested in listening to a strong statement about building hybrid software / hardware transactional memory systems.As someone who has written papers on transactional memory systems, I am still unconvinced that they are the panacea

Signals and Java

2007-06-25T23:31:00.000-07:00

Ooookay. You are now, presumably, fresh from reading the original post about using AsyncGetCallTrace and the more recent post about how to use SIGPROF in C++. The next obvious question is...Can I Register a Signal Handler in Java?Um... Kind of!There is an undocumented and unsupported interface called sun.misc.Signal present in most Java implementations. For those of you who have downloaded

More about profiling with SIGPROF

2007-06-25T22:02:00.000-07:00

First, read this post about profiling with JVMTI and SIGPROF.A poster on that entry asked me to elaborate a little on exactly what happens when the timer goes off and the signal is raised. In this post, I'll explain that in a little more detail. First, I'll back up a little.Edited to add: Okay, I wrote this whole thing, and very, very briefly answered the actual question at the end. So, if you

Answer to Weekend Multithreaded Puzzler

2007-06-09T11:39:00.001-07:00

This is the answer to the riddle posed in my earlier puzzler posting. You should probably look at that question before looking at this answer. I suppose I should call it something other than a puzzler, to avoid getting hit by Josh and Neal's angry team of vicious, snarling lawyers...This program certainly looks straightforward. It just looks as if two threads are writing to two variables. In

Weekend Multithreaded Puzzler Fun!

2007-06-09T11:17:00.000-07:00

Although I didn't go this year, one of my favorite parts of JavaOne is always Josh Bloch and Neal Gafter's talk on Java Puzzlers. (This year, Bill Pugh, my graduate advisor, stepped in for Neal.) A puzzler is a short snippet of code which has unexpected results, usually because some language or API feature behaves in a strange way. I enjoy them because I always think it is truly wonderful to

More thoughts on SIGPROF, JVMTI and stack traces

2007-06-04T22:00:00.001-07:00

This is a follow up from my previous post about profiling with SIGPROF and JVMTI.There are, in fact, a very large number of ways of getting stack traces out of a JVM. If you send a system-dependent signal to your JVM process, it will spit out a stack dump of every currently live thread. On Solaris and Linux, the signal is a SIGQUIT, which you can get by using kill -3 on the JVM PID (or the PID

C++ Threads

2007-06-04T16:26:00.000-07:00

There is a very good talk by Lawrence Crowl on the upcoming threading changes to C++. I wrote a brief entry about his talk on C++0x (where they are hoping for x < 10). They have developed heavily on the work done for the Java model, so that they could resolve some of the C++ absurdities that inevitably occur. Hans Boehm, who was heavily involved in the Java effort, has been leading the

Double-Checked Locking and the Problem with Wikipedia

2007-05-23T20:17:00.000-07:00

I love Wikipedia, I really do. I use it for everything. Well, not everything. For example, if I want a really good piece of chocolate cake, I tend to use flour, sugar, butter, eggs, chocolate, and not Wikipedia at all. For many things, however, Wikipedia cannot be surpassed.Imagine, then, my surprise when I found out that their page on Double-Checked Locking gave an example of a version of

Profiling with JVMTI/JVMPI, SIGPROF and AsyncGetCallTrace

2007-05-14T16:22:00.000-07:00

This post is not about the memory model, but, instead, is about being able to get, asynchronously, the stack trace of a currently executing thread out of Sun's Java VM. Getting one synchronously is easy, of course.I was trying to profile some Java applications under Linux, and I wanted to use SIGPROF and JVMTI to find out what code was running at any given second. This is just a posting to

Google Talks

2007-05-11T00:36:00.000-07:00

By the way, gentle reader, in case you haven't noticed, I am running a series of talks at Google.All of them can be found here.

Roach Motels and The Java Memory Model

2007-05-11T00:02:00.000-07:00

I've been asked by a couple of people lately about what a compiler can do with code motion around synchronized blocks. The first person asked me about the following example, so let's run with it:x = 1;synchronized(o) { z = z + 1;}y = 1;I may have answered this already (at some point), but I feel free to repeat myself.The JMM has what we call "roach motel" ordering. "Roach Motel" is Black Flag's

Software Transactional Memory Talk at Google

2007-05-01T18:53:00.000-07:00

Adam Welc, from Intel's Programming Systems Lab, came to Google to give a talk about what they are doing in the realm of Software Transactional Memory. He also talks briefly, at the end, about Intel's hardware plans.For those who are interested in such things, this is a talk worth seeing.Click Here.

Lock-Free Hash Tables

2007-04-17T13:41:00.000-07:00

I forgot to post about this at the time. Cliff Click gave a talk about his lock-free hashtable at Google; it is definitely worth a peek. Available here.There is a very funny thread on the concurrency-interest mailing list this week about "lock-free mania". Apparently, software engineers are going to start choosing "trendy" lock-free data structures for no valid reason, resulting in lots of

Fairness

2007-04-10T20:52:00.000-07:00

Okay, so I lied about the contents of my next post. I bet no one even notices. Anyone even reading these? Yeah, right.I was asked a question about fairness. The notion of fairness is one where there are some number of individual entities trying to make progress (in our case, threads), and there is some level of guarantee that this will actually happen.Java has no meaningful fairness guarantee

Safe Construction and the JMM

2007-03-31T18:55:00.000-07:00

Another question from a viewer. We have this code:class C { private int x; public C(int v) { this.x = v; } public synchronized int get() { return this.x; } public synchronized void set(int v) { this.x = v; }}(For the actual question as it was worded, the short answer is, "yes")The question was one I get a lot. He asked how one thread can safely read the initial write of v to x.

Slides from JMM talk

2007-03-28T15:41:00.001-07:00

The slides from the JMM talk are available here for people's perusal. Enjoy!

Volatile Fields and Synchronization

2007-03-27T14:54:00.000-07:00

A question from a viewer. In my talk, I had a class that looked like this:class Future { private volatile boolean ready; private Obj data; ... public synchronized void setOnce(Obj o) { if (ready) throw ...; data = o; ready = true; } public Object get() { if (!ready) return null; return data; }}The setOnce method is executed by one thread, and get is executed by another. The point of this

JMM Talk at Google

2007-03-26T14:15:00.000-07:00

This fellow is rather handsome, dashing and well-informed. If you would like a primer on the Java memory model, this is a good place to start. I was running out of time toward the end, though, so the last 15 minutes may be a little rushed. Perhaps I'll do a two-part followup at some point.One thing I forgot to say, at the very beginning: The Java memory model defines how threads interact

HashMap Behavior in JDK6

2007-03-22T23:54:00.000-07:00

It is important to read the documentation. Lots of people don't seem to do this, and they get bitten by it.The iterator for java.util.HashSet is documented as follows:Returns an iterator over the elements in this set. The elements are returned in no particular order.Of course, I've now seen code that ignores this, so I thought I would draw a few underlines for the kind of folks who miss it. I

Loop Invariant Code Motion and the Java Memory Model

2007-03-21T21:20:00.000-07:00

I gave a talk on the Java memory model this afternoon, and there was a question from the audience which I didn't answer to my own satisfaction, so I am answering it again, for my vast readership of none.At issue was the following bit of code:class Animator implements Runnable { private volatile boolean stop = false; public void stop() { stop = true; } public void run() { while (!stop) {

JMM questions go here

2007-03-21T12:18:00.000-07:00

I just gave a talk in which I said that people could post questions on the Java memory model here. So feel free to post JMM questions below!

C++ Is Getting More Like Java Every Day

2007-03-13T00:34:00.000-07:00

Lawrence Crowl gave an interesting talk at Google last week. It would seem that the next revision of the C++ standard is getting:A new memory model,Garbage collection,Concepts (which are more-or-less type checking for templates. This roughly boils down to "generics")Unicode support,A regular expression library,A for-each loop!This is all starting to sound terribly familiar. I'm starting to