Best way to synchronize in a Singleton

Question

I have this classimport java.util.ArrayList;
import java.util.List;
public class SynchIssues
  private List values = new ArrayList();
  private static final SynchIssues singleton = new SynchIssues();
  public static SynchIssues getInstance()
    return singleton;
  public void addValue(String value)
    synchronized(singleton)
      values.add(value);
  public String getValue(int i)
    synchronized (singleton)
      return (String) values.get(i);
}And i synchronize on the singleton itself , but some collegue uses a different approach
import java.util.ArrayList;
import java.util.List;
public class SynchIssues2
  private List values = new ArrayList();
  private static final SynchIssues2 singleton = new SynchIssues2();
  public static SynchIssues2 getInstance()
    return singleton;
  public synchronized void addValue(String value)
      values.add(value);
  public synchronized String getValue(int i)
      return (String) values.get(i);
}He uses synchronize on the methods in stead of the SIngleton.
What approach is best ?
Are both approaches thread safe ?
Do teh different approaches risk deadlocking when different thread will be accessing the classes ?

Answer 1

What do you need to do exactly? What does "the most thread-safe" mean?
If I read correctly your code samples, the fact that the "shared object" is a singleton is not relevant. Your point seems to be more about a generic issue of "synchronizing access to a shared collection".
Without resorting to bytecode examination, it seems your 3 code samples look equivalent as far as individual add() and get() operations are concerned: each operation is atomic, and only one thread is actually reading/modifying the collection at a given time. In this regard each of these operations can be told "thread-safe".
However it gives absolutely no guarantee about several operations executed in sequence : two threads executing such a sequence would probably see their get() and add() interleaved. This may or may not cause a problem depending on your application (what you do about the data in the collection, and in particular how you react to reaching the end of the list).
If you want this kind of guarantee of per-sequence atomicity (a sequence of, e.g., get() is executed without any other thread modifying the collection in between), you have to make sure each client synchronizes on the collection (or on the singleton, if it's the only wrapper) around the whole block of the sequence:
SynchIssueX singleton = SynchIssueX.getInstance();
// make sure no other thread may read any value before I've added them all:
synchronized (singleton) {
  singleton.add(value1);
  singleton.add(value2);
  singleton.add(value3);
}