CODEWITHSUNDEEP
javamultithreading
curiousity
curiousity

Reputation: 4741

10 threads write to single hash simultaniously

Sorry for the question(( I just have stuck in the end of the day(( I need for test 10 threads writing to the same hash (really not a hash but very similar thing i need to prove it synchronization for write) is this is right code?

Random rn = new Random();

Map<int,int> hash = new MyHashMap<int,int>();

for(int i = 0; i< 10; i++)
{
 Thread th = new MyAddingThread();
 th.Start();
}

public class MyAddingThread extends Thread{
 public void run()
 {
   hash.Add(rn.nextInt,rn.nextInt);
 }
}

May be better to change 10 to 100. but I have no idea how to test dat hash for synchronization(

Upvotes: 2

Views: 77

Answers (3)

Arne Burmeister
Arne Burmeister

Reputation: 20594

A HashMap is not synchronized so you have to do it on your own!

You may synchronize the access:

public class MyAddingThread extends Thread {
  public void run() {
    synchronized(hash) {
      hash.put(rn.nextInt(),rn.nextInt());
    }
  }
}

but than you miss most of the concurrent execution.

Another idea is to use a ConcurrentHashMap:

ConcurrentMap<Integer,Integer> hash = new ConcurrentHashMap<>();

public class MyAddingThread extends Thread {
  public void run() {
    hash.put(rn.nextInt(),rn.nextInt());
  }
}

This would give more performance due to less blocking code.

The other problem is the use of Random here which is thread safe but will also result in poor performance.

Which solution is the best for your problem I cannot consider from your little pseudo code.

Upvotes: 1

Tony the Pony
Tony the Pony

Reputation: 41357

HashMap is not thread-safe. Use a ConcurrentHashMap instead.

EDIT

If your real question is whether your code will allow you to test whether any given data structure is thread-safe or not, there really is no reliable way to do so. Multi-thread development can introduce any number of bugs that can be extremely difficult to detect. A data structure is either designed to be thread-safe, or it is not.

Upvotes: 4

Augusto
Augusto

Reputation: 29877

That won't work, as all threads should try to add the item to the hash at the same time.

To do that, you need to use a CountDownLatch

[[main]]
CountDownLatch startSignal = new CountDownLatch(1);
for(int i = 0; i< 10; i++)
{
 Thread th = new MyAddingThread();
 th.Start();
}
startSignal.countdown();


[[on the thread]]    
public class MyAddingThread extends Thread{
 public void run()
 {
   startSignal.await();
   hash.Add(rn.nextInt,rn.nextInt);
 }
}

The javadoc of this class has a similar (but more complex) example.

Also, if you want to test this properly, create the same number of threads as cores in your computer and each thread should do a loop and insert a few hundred items at least. if you try to only insert 10 elements, there are very little chances that you'll hit a concurrent problem.

Upvotes: 1

Related Questions