Re: Cannot seem to lock HashMap

Lew -

Sorry for the TABS (I copied code from Eclipse). I do agree that your
code may work, but I would be paying penalty of having to synchronize
(lock) for every call that uses "values".

But I found solution that allows me to ONLY synchronize methods that
either depend on the map NOT getting modified, and methods that modify
the map. To do this I must synchronize all methods that can modify
the map, but all methods that don't need to synchronize the map (such
as get() don't depend on any locking) are not synchronized so there is
no locking and thus are faster.

Any methods that depend on the map data TO NOT CHANGE I explicitly
lock the container class. This is the best approach because I don't
have to pay penalty for locking (synchronizing) all of my methods -
which is the solution I was looking for as speed is very important to
me in this code.

See example (two classes):

public class TestIndex {

    public static void main(String[] args) {

        TestContainer c = new TestContainer();
        new Thread_1(c).start();
        new Thread_2(c).start();
    }

    public static class Thread_1 extends Thread {

     TestContainer c;

     public Thread_1(TestContainer c) {
     super("Thread_1");
     this.setDaemon(false);
     this.c = c;
     }

     public void run() {
     Date start = new Date();
     System.out.println("Thread_1 run...");
            try {
                for (int i=0; i<1000000; i++) {
                    Date key = new Date();
                    c.put(key,new Date());
                    c.get(key);
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
            Date end = new Date();
            long diff = end.getTime() - start.getTime();
            System.out.println("Thread_1 END: " + diff + " total time");
     }
    }

    public static class Thread_2 extends Thread {

     TestContainer c;

     public Thread_2(TestContainer c) {
     super("Thread_2");
     this.setDaemon(false);
     this.c = c;
     }

     public void run() {
     Date start = new Date();
     System.out.println("Thread_2 run...");
            try {
                for (int i=0; i<1000000; i++) {
                    c.clone();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
            Date end = new Date();
            long diff = end.getTime() - start.getTime();
            System.out.println("Thread_2 END: " + diff + " total time");
     }
    }
}

public class TestContainer {

    private HashMap<Date, Date> _values;

    public TestContainer() {
        _values = new HashMap<Date, Date>();
    }

    public TestContainer(HashMap<Date, Date> v) {
        _values = v;
    }

    public void put(Date key, Date value) {
        _values.put(key, value);
    }

    public Date get(Date key) {
        return _values.get(key);
    }

    public Object clone() {

     HashMap<Date, Date> cValues = new HashMap<Date,
Date>(_values.size());

     synchronized (this) {
     cValues.putAll(_values);
     }
     return new TestContainer(cValues);
    }
}