Java synchronized statement

Question

I need a threadsafe arraylist like this.

public class BookingList {

  private List<Booking> bookings;

  public BookingList() {
      bookings = Collections.synchronizedList(new ArrayList<Booking>());
  }

  @Override
  public void addBooking(Booking booking)
  {
    synchronized (bookings) {
        bookings.add(booking);
    }   
  }

  @Override
  public void removeBooking(Booking booking)
  {
    synchronized (bookings) {
        bookings.remove(booking);
    }   
  }
}

According to java doc, when using Collections.synchronizedList one needs to synchronize each access to the list. I'm not sure whether my synchronized blocks will do this?

Is my use of synchronized blocks equivalent to

...
public synchronized void addBooking(Booking booking) {
  bookings.add(booking);
}

Should I use a ReentrantLock like this

private Lock lock = new ReentrantLock();
public void addBooking(Booking booking) {
  try {
    lock.lock;
    bookings.add(booking);
  } finally {
    lock.release();
  }
}

U can refer this link it will solve your problem [click here][1] [1]: http://stackoverflow.com/questions/3814325/how-to-create-synchronized-arraylist — Ashish Chaurasia, Jun 20 '13 at 14:03

score 6 · Accepted Answer · answered Jun 20 '13 at 13:47

6

You don't need to synchronize simple operations like add or remove because this is handled internally by the implementation and this is precisely why you use them: to avoid handling the synchronization yourself

But for composite operations like iterations or multiple removal that are out of the scope of the internal synchronization you must provide your own locking mechanism.

answered Jun 20 '13 at 13:47

Pragmateek

13,174
9
74
108

But then I have both an add method without synchronizing and a method that makes some sort of iteration. Then I only do synchronize on the iteration method. How can Java know that the synchronization of the add and iteration-method is the same? To clarify: I see that 2 different threads cannot call "add" simultaneously, but can one thread call add and the other the iteration.method? – Vering Jun 21 '13 at 07:49
If you synchronize on the whole list you should not have any issue: `synchronized(bookings){ // iterate ... }` because both the *add* method and your iteration will use the same lock. – Pragmateek Jun 21 '13 at 15:11

score 3 · Answer 2 · answered Jun 20 '13 at 13:52

3

To answer your questions:

1:

public synchronized void addBooking(Booking booking) {
   bookings.add(booking);
}

is equivalent to

public void addBooking(Booking booking) {
   synchronized (this){
       bookings.add(booking);
   }
}

2: for your example you should not use ReentrantLock. Calling methods of a list that has been initialized with Collections.synchronizedList() is thread-safe, no further synchronized or other locking mechanisms have to be used. For the rest see @Pragmateek's answer.

answered Jun 20 '13 at 13:52

Sebastian

5,177
4
30
47

this.class should be this :) – Narendra Pathai Jun 20 '13 at 13:54
2

True. I changed it. `this.class` will be used for static methods. – Sebastian Jun 20 '13 at 13:54

Java synchronized statement

2 Answers2