Java Concurrency Gotchas

Java Concurrency
Gotchas

Alex Miller

Questions to answer

• What are common concurrency problems?
• Why are they problems?
• How do I detect these problems?
• How to I correct these problems?

Areas of Focus

• Shared Data
• Coordination
• Performance

Areas of Focus

{
• Locking
• Shared Data • Visibility
• Atomicity
• Coordination
• Safe Publication
• Performance

Unprotected Field
Access

A

What happens if we modify data
without locking?

Writer

Readers
Shared state

Shared Mutable Statics
public class MutableStatics {
FORMAT is mutable
private static final DateFormat FORMAT =
DateFormat.getDateInstance(DateFormat.MEDIUM);

public static Date parse(String str)
throws ParseException {
return FORMAT.parse(str);
} ...and this mutates it outside synchronization

public static void main(String arg[])
throws Exception {
MutableStatics.parse(“Jan 1, 2000”);
}
}

Shared mutable statics -
instance per call

DateFormat format =
DateFormat.getDateInstance(DateFormat.MEDIUM);
return format.parse(str);
}

public static void main(String arg[])
throws Exception {
MutableStatics.parse(“Jan 1, 2000”);
}
}

Shared mutable statics -
ThreadLocal
private static final ThreadLocal<DateFormat> FORMAT
= new ThreadLocal<DateFormat>() {
@Override protected DateFormat initialValue() {
return DateFormat.getDateInstance(
DateFormat.MEDIUM);
}
};

return FORMAT.get().parse(str);
}
}

Common JDK Examples

Danger! Safe

• DateFormat • Random
• Calendar • Pattern
• Matcher

Synchronization

private int myField;

synchronized( What goes here? ) {
myField = 0;
}

DO NOT:
synchronize on null
MyObject obj = null;

synchronized( obj ) { NullPointerException!
// work
}

DO NOT:
change instance
MyObject obj = new MyObject();

synchronized( obj ) {
obj = new MyObject();
no longer synchronizing
on same object!
}

DO NOT:
synch on string literals
private static final String LOCK = “LOCK”;
synchronized( LOCK ) {
// work
What is the scope of LOCK?
}

DO NOT:
synch on autoboxed vals
private static final Integer LOCK = 0;
synchronized( LOCK ) { What is the scope of LOCK?
// work
}

DO NOT:
synch on ReentrantLock
Lock lock = new ReentrantLock();
synchronized(lock) {
// ... Probably not what you meant here
}

Lock lock = new ReentrantLock();
lock.lock();
Probably more like this...
try {
// ...
} finally {
lock.unlock();
}

What should I lock on?
// The field you’re protecting
private final Map map = ...
synchronized(map) {
// ...access map
}

// Explicit lock object
private final Object lock = new Object();
synchronized(lock) {
// ...modify state
}

Visibility problems
int x = 5;

Thread 1:
if(x == 5) {
x = 10;
}

Thread 2:
System.out.println(x);

Visibility problems
volatile int x = 5;

Thread 1:
if(x == 5) {
x = 10;
}

Thread 2:
System.out.println(x);

Inconsistent
Synchronization
public class SomeData {
private final Map data = new HashMap();

public void set(String key, String value) {
synchronized(data) { Protecting writes
data.put(key, value);
}
}

public String get(String key) {
return data.get(key); ...but not reads
}
}

Double-checked locking
public class Singleton {
private static Singleton instance;

public static Singleton getInstance() {
if(instance == null) { Attempt to avoid synchronization
synchronized(Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

private static Singleton instance;

if(instance == null) { READ
if(instance == null) { READ
instance = new Singleton(); WRITE
}
}
}
return instance;
}
}

- volatile
private static volatile Singleton instance;

instance = new Singleton();
}
}
}
return instance;
}
}

- initialize on demand
private static class SingletonHolder {
private static final Singleton instance
= new Singleton();
}

return SingletonHolder.instance;
}
}

volatile arrays
public final class VolatileArray {

private volatile boolean[] vals;

public void flip(int i) {
Is the value of vals[i]
vals[i] = true; visible to other threads?
}

public boolean flipped(int i) {
return vals[i];
}
}

Volatile counter
public class Counter {

private volatile int count;

public int next() {
return count++; Looks atomic to me!
}
}

AtomicInteger counter
public class Counter {

private AtomicInteger count =
new AtomicInteger();

public int next() {
return count.getAndIncrement();
} Really atomic via
} encapsulation over
multiple actions

Composing atomic actions
public Object putIfAbsent(
Hashtable table, Object key, Object value) {
Hashtable is
thread-safe

if(table.containsKey(key)) { READ
// already present, return existing
table.get(key); READ
return null;

} else {
// doesn't exist, create new value WRITE
return table.put(key, value);
}
}

Participate in lock
Hashtable table, Object key, Object value) {
Hashtable is
thread-safe

synchronized(table) {
if(table.containsKey(key)) {
table.get(key);
return null;
} else {
return table.put(key, value);
}
}
}

Encapsulated compound
actions
ConcurrentHashMap table, Object key, Object value) {

return table.putIfAbsent(key, value);
}
Encpasulation FTW!

Assignment of
64 bit values
public class LongAssignment {

private long x;

public void setLong(long val) {
x = val;
Looks atomic to me,
}
but is it?
}

Assignment of
64 bit values - volatile
public class LongAssignment {

private volatile long x;

public void setLong(long val) {
x = val;
}

}

Listener in constructor
public interface DispatchListener {
void newFare(Customer customer);
}

public class Taxi
implements DispatchListener {

public Taxi(Dispatcher dispatcher) {
dispatcher.registerListener(this); We just published a
// other initialization reference to this...oops!
}

public void newFare(Customer customer) {
// go to new customer’s location
}
}

Starting thread
in constructor
public class Cache {

private final Thread cleanerThread;

public Cache() {
cleanerThread = new Thread(new Cleaner(this));
cleanerThread.start(); this escapes again!
}

// Clean will call back to this method
public void cleanup() {
// clean up Cache
}
}

Static factory method
public class Cache {
// ...

public static Cache newCache() {
Cache cache = new Cache();
cache.startCleanerThread();
return cache;
}
}

Areas of Focus

• Shared Data
• Coordination
• Performance
{ • Threads
• Wait/notify

• THOU SHALT NOT:
• call Thread.stop() All monitors unlocked by ThreadDeath

• call Thread.suspend() or Thread.resume()
Can lead to deadlock

• call Thread.destroy() Not implemented (or safe)

• call Thread.run() Wonʼt start Thread! Still in caller Thread.

• use ThreadGroups Use a ThreadPoolExecutor instead.

wait/notify
// Thread 1
synchronized(lock) { You must synchronize.
while(! someCondition()) { Always wait in a loop.
lock.wait();
}
}

// Thread 2
synchronized(lock) { Synchronize here too!
satisfyCondition();
lock.notifyAll();
}

Condition is similar
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();

public void waitTillChange() {
lock.lock();
try {
while(! someCondition()) condition.await();
} finally {
lock.unlock();
} Condition is more
ﬂexible than wait/notify.
}
public void change() {
lock.lock();
try {
satisfyCondition();
condition.signalAll();
} finally { lock.unlock(); } }

Areas of Focus

• Shared Data
• Coordination • Deadlock
• Performance { • Spin wait
• Thread contention

Deadlock
// Thread 1
synchronized(lock1) {
// stuff
}
}
Classic deadlock.
// Thread 2
// stuff
}
}

Deadlock avoidance

• Lock splitting
• Lock ordering
• Lock timeout
• tryLock

Spin wait
// Not efficient
private volatile boolean flag = false;

while(! flag) {
Thread.sleep(100); Spin on ﬂag, waiting for
a change.
}
}

flag = true;
}

Replace with Condition
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
private boolean flag = false;

lock.lock();
try {
while(! flag) condition.await();
} finally {
lock.unlock(); Better but longer.
}
}
lock.lock();
try {
flag = true;
condition.signalAll();
} finally { lock.unlock(); } }

CountDownLatch
private final CountDownLatch latch =
new CountDownLatch(1);

latch.await();
}

latch.countDown();
Coordination classes
}
like CountDownLatch
and CyclicBarrier cover
many common uses
better than Condition.

Lock contention
x

Hash f(x)

Bucket 0 Bucket 1 Bucket 2 Bucket 3

Lock striping
x

Hash g(x)

Hash f(x) Hash f(x)

Bucket 0 Bucket 1 Bucket 0 Bucket 1

Final Exam
public class StatisticsImpl implements Statistics,
StatisticsImplementor {
private long queryExecutionCount;

public synchronized void queryExecuted(
String hql, int rows, long time) {
queryExecutionCount++;
// ... other stat collection
}

public long getQueryExecutionCount() {
return queryExecutionCount;
}

public synchronized void clear() {
queryExecutionCount = 0;
// ... clear all other stats
}
}

Final Exam
public class StatisticsImpl implements Statistics,
StatisticsImplementor {
private long queryExecutionCount;
Single shared lock for ALL stat values
public synchronized void queryExecuted(
String hql, int rows, long time) {
queryExecutionCount++;
// ... other stat collection
}

public long getQueryExecutionCount() {
return queryExecutionCount;
Read shared value Non-atomic read
}
w/o synchronization of long value
public synchronized void clear() {
queryExecutionCount = 0;
Race condition if reading
// ... clear all other stats stat and clearing
}
}

Thanks...
Twitter http://twitter.com/puredanger
Blog http://tech.puredanger.com
Concurrency http://concurrency.tumblr.com
links
http://refcardz.dzone.com/refcardz/
Refcard
core-java-concurrency
Slides http://slideshare.net/alexmiller

Java Concurrency Gotchas

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java Concurrency Gotchas (20)

More from Alex Miller (12)

Recently uploaded (20)

Java Concurrency Gotchas