synchronizedList access by multiple threads

Will the Both thread able to access the Both(add and remove) api at the same time.

The answer is no.

If you get a chance to look at Collections.synchronizedList(List) source code, you see that, the method is creating the instance of a static inner class named SynchronizedList or SynchronizedRandomAccessList, depending on the type of List you send as argument.

Now both these static inner class extend a common class called SynchronizedCollection, which maintains a mutex object, on which all method operations synchronize on

This mutex object is assigned with this, which essentially means that, the mutex object is the same returned instance.

Since the add() and remove() methods are performed under the

synchronized(mutex) {

}

block, a thread which executes add (and aquires lock on mutex), will not allow another thread to execute remove (by aquiring lock on same mutex), since the former has already locked the mutex. The latter thread will wait until the lock obtained by former thread on mutex gets released.

So, yes add() and remove() are mutually exclusive

Can you clarify what you mean with "at the same time"?

A synchronized data structure will force one of the two threads to wait until the other has completed its operation. The "wait-on-lock" can be enforced at various levels of granularity, and can allow reads while synchronizing writes (including deletes), but the principle remains the same.

i'd solve your problem in this way:

First i create a list wrapper class like this:

public class MySyncList{
   private List<String> myList;
   public MySyncList(){
      this.myList = new ArrayList<String>();
   }
   public synchronized void add(String elem){
      this.myList.add(elem);
   }
   public synchronized void remove(String elem){
      this.myList.remove(remove);
   }
   public synchronized List<String> getList(){
      return this.myList;
   }
}

Than access from threads:

final MySyncList list = new MySyncList(); // final so other threads can access it

ExecutorService service = Executors.newFixedThreadPool(10);
for(int i=0;i<20;i++){
   service.execute(new Runnable(){
      public void run(){
         list.add("something");
         list.remove("something");
      }
   });
}
service.shutDown();
while(!service.isTerminated());
List<String> finalList = list.getList();

That is correct, the synchronized list is fully thread safe. So in terms of atomicity the threads will not able to access the list simultaneously. The access from different threads will happen in a serial manner.