Frequent Object Creation vs. synchronized

Question

HI all,
I'm just looking to prompt a discussion I can learn from. Apologies if I'm missing something.
Having just read the excellent articles over at:
http://www-106.ibm.com/developerworks/java/library/j-threads1.html
http://www-106.ibm.com/developerworks/java/library/j-threads2.html
http://www-106.ibm.com/developerworks/java/library/j-threads3.html
I was left wondering about the (largely unmentioned) trade-off between object creation and use of synchronization.
If a particular part of a given system is heavily accessed then one might consider instantiating, and caching references to, components in an initialisation stage. In a multithreaded environment, this can obviously pose a problem.
If these components aren't threadsafe then at some point use will have to be made of a synchronized block, unless the unsafe components are instantiated for every thread.
The articles do mention the overrated cost of synchronization - how does this compare with the cost of frequent object instantiation?
Thanks for your time,
JohnG

Answer 1

Well, let's time it (test program below):
using no synchronization: 180 ms (baseline measurement, not thread safe)
using new: 1111 ms
using uncontended sync: 491 ms
using contended sync: 49531 ms
new is fast - ten million temporary object allocations and frees per second. A magnitude faster than in traditional malloc()/free() -based languages. new is rarely a performance problem in Java programs.
Uncontended locks are fast - twenty million per second.
Heavily contended locks slow you down. Way down. A second becomes a minute.
Don't try to optimize unless you have measured a real performance bottleneck.
Object pooling is unlikely to help. Exceptions being objects that are expensive to initialize and are created often (e.g. large buffers or arrays, cryptographic engines that take time to initialize, or connections to external systems such as databases). You'll need to measure first if object creation really is the bottleneck.
public class t
    static class Calculator
     private int value;
     void initialize(int n)
         value = n;
     int result()
         return value * 2;
    static class NewThread
     extends Thread
     int result;
     public void run()
         for (int n = 0; n < 1000 * 1000; n++) {
          Calculator x = new Calculator();
          x.initialize(n);
          result += x.result();
    static class SyncThread
     extends Thread
     static Calculator x = new Calculator();
     int result;
     public void run()
         for (int n = 0; n < 1000 * 1000; n++) {
          synchronized (x) {
              x.initialize(n);
              result += x.result();
    // Not thread safe
    static class BaselineThread
     extends Thread
     static Calculator x = new Calculator();
     int result;
     public void run()
         for (int n = 0; n < 1000 * 1000; n++) {
          x.initialize(n);
          result += x.result();
    public static void main(String args[])
     throws Exception
     int thread_count = 10;
     for (int n = 0; n < 5; n++) {
         Thread threads[] = new Thread[thread_count];
         long start = System.currentTimeMillis();
         for (int m = 0; m < thread_count; m++) {
          // threads run consecutively, not in parallel
          (threads[m] = new BaselineThread()).start();
          threads[m].join();
         long end = System.currentTimeMillis();
         System.out.println("using no synchronization: " +
                      (end - start) + " ms");
     for (int n = 0; n < 5; n++) {
         Thread threads[] = new Thread[thread_count];
         long start = System.currentTimeMillis();
         for (int m = 0; m < thread_count; m++)
          (threads[m] = new NewThread()).start();
         for (int m = 0; m < thread_count; m++)
          threads[m].join();
         long end = System.currentTimeMillis();
         System.out.println("using new: " + (end - start) + " ms");
     for (int n = 0; n < 5; n++) {
         Thread threads[] = new Thread[thread_count];
         long start = System.currentTimeMillis();
         for (int m = 0; m < thread_count; m++) {
          // threads run consecutively, not in parallel
          (threads[m] = new SyncThread()).start();
          threads[m].join();
         long end = System.currentTimeMillis();
         System.out.println("using uncontended sync: " +
                      (end - start) + " ms");
     for (int n = 0; n < 5; n++) {
         Thread threads[] = new Thread[thread_count];
         long start = System.currentTimeMillis();
         for (int m = 0; m < thread_count; m++)
          (threads[m] = new SyncThread()).start();
         for (int m = 0; m < thread_count; m++)
          threads[m].join();
         long end = System.currentTimeMillis();
         System.out.println("using contended sync: " +
                      (end - start) + " ms");
}