Synchronizing many reader threads with one writer thread?

Question

Hi
I was wondering if there is a way in java to allow different threads to read an object simultaneously however to block them all only when the object is being updated. Here is an example:
I have the following object which is shared between many Servlet instances:
public class ActiveFlights
     private final HashMap<String,Flight> flights;
     private final Object lock;
     public ActiveFlights()
          flights = new HashMap<String, Flight>();
          lock = new Object();
     public void updateFlights(ArrayList<FlightData> newFlights)
          synchronized (lock)
               //some code which updates the HashMap
     public ArrayList<Flight> getSomeFlights()
          ArrayList<Flight> wantedFlights = new ArrayList<Flight>();
          synchronized (lock)
               //some code which selects flights from the HashMap
          return wantedFlights;
}Now all the Servlet doGet() functions call the getSomeFlights() method. There is also a Timer object which calls the updateFlights() method once every few minutes.
I need the synchronized blocks in order that the Timer doesn't try to update my object while it is being read by a Servlet however this is not optimal since it also causes each Servlet doGet() to block the others even though it would be possible for to doGet()'s to read the object simultaneously.
Is there a better way of doing this?
Thanks
Aharon

Answer 1

It is highly unlikely this is a real performance issue for you. Unless you know this is a bottle neck, you don't need to change your code.
However, as an exercise, you can just use ConcurentHashMap for lockless Map access. However, there is still a risk of getting a read in the middle of a write.
Instead you can take a snapshot copy of the Map and use this snapshot for reads. See below.
In term of coding style;
- I suggest you use the Map and List interfaces where ever possible.
- You don't need to create a seperate lock object, the Map will do the same job.
- Use can create the HashMap on the same line as it is declared removing the need to define a constructor.
public class ActiveFlights {
     private final Map<String, Flight> flights = new HashMap<String, Flight>();
     private volatile Map<String, Flight> flightCopy = new HashMap<String, Flight>();
     public void updateFlights(List<FlightData> newFlights) {
          //some code which updates the HashMap
          // this takes a snapshot copy of the flights.  Use the copy for reads.
          flightCopy = new HashMap<String, Flight>(flights);
     public List<Flight> getSomeFlights() {
          // take a copy of the reference, neither the reference, nor the map it refers to will change over the life of this method call.
          final Map<String, Flight> flightCopy = this.flightCopy;
          final List<Flight> wantedFlights = new ArrayList<Flight>();
          //some code which selects flightCopy from the HashMap
          return wantedFlights;
}