Re: Cannot seem to lock HashMap
On Aug 15, 5:43 pm, Owen Jacobson <angrybald...@gmail.com> wrote:
On Aug 15, 4:52 pm, byo...@hotmail.com wrote:
Basically the situation is that I have a HashMap (yes I know this is
not synchronized and therefore must do it manually). The HashMap is
used by two threads running concurrently, and one thread is adding
values to the map while the other is iterating over the values. Now
typically I would expect to get the ConcurrentModificationException -
but I have tried to synchronize the object manually without any luck.
Perhaps I don't understand locking, but according to Java 1.5 API this
should work, I wrote the following test class to demonstrait what I am
trying to do:
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class TestIndex {
public static HashMap<Date, Date> values = new HashMap<Date, Date>();
public static void main(String[] args) {
new Thread_1().start();
new Thread_2().start();
}
public static class Thread_1 extends Thread {
public Thread_1() {
super("Thread_1");
this.setDaemon(false);
}
public void run() {
System.out.println("Thread_1 run...");
try {
for (int i=0; i<1000000; i++) {
TestIndex.values.put(new Date(),new Date());
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Thread_1 END");
}
}
public static class Thread_2 extends Thread {
public Thread_2() {
super("Thread_2");
this.setDaemon(false);
}
public void run() {
System.out.println("Thread_2 run...");
try {
for (int i=0; i<1000000; i++) {
Map m = Collections.synchronizedMap(TestIndex.values);
synchronized (m) {
HashMap<Date, Date> newMap = new HashMap<Date, Date>(m);
}
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Thread_2 END");
}
}
}
Your Thread_1 thread is not participating in any synchronization
whatsoever, which means your Thread_2 reader thread is subject to race
conditions in a number of ways. As SadRed suggested, use the
synchronizedMap wrapper provided by Collections; alternately, have
Thread_1 also synchronize on the map while inserting entries:
public void run() {
System.out.println("Thread_1 run...");
try {
for (int i=0; i<1000000; i++) {
synchronized (TestIndex.values) {
TestIndex.values.put(new
Date(),new Date());
}
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Thread_1 END");
}- Hide quoted text -
- Show quoted text -
As to what I am trying to do: Basically I want to use the HashMap vs.
Hashtable because it is faster, and because there is really only one
situation that I have that needs to be synchronized. That situation
is when I need to clone my HashMap. Unfortunatly when cloning my
HashMap it is very likely that another thread is adding or removing
values to the HashMap. So I need to somehow lock down the HashMap so
that it cannot be modified while the clone method is called.
I tried to use the Collections.synchronizedMap() - with a synchronized
block of code, thinking that this would "lock" the HashMap from
allowing other threads to put values until after the synchronized
block has completed. However it now occurs to me that I have to do
this in both threads, otherwise it will not work. This leads me to
think I should just use Hashtable since I cannot lock HashMap when I
need to (all or nothing).
The above code is just an example to throw the concurrent exception, I
know that it is just "throwing away" the HashMap it creates in thread
2. Again this is just for demo purposes.