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

Viewers also liked

Similar to Java Concurrency Gotchas

More from Alex Miller

Recently uploaded

Java Concurrency Gotchas