Java 10个线程同时写入单个散列

对不起，我的问题（我刚把话说完(( 我需要测试10个线程写入同一个散列（实际上不是散列，但非常类似，我需要证明它是同步写入） 这是正确的密码吗

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);
 }
}

Random rn=new Random（）；
Map hash=new MyHashMap（）；
对于（int i=0；i<10；i++）
{
线程th=新的MyAddingRead（）；
th.Start（）；
}
公共类MyAddingRead扩展线程{
公开募捐
{
hash.Add（rn.nextInt，rn.nextInt）；
}
}

---

将10更改为100可能更好。但我不知道如何测试dat哈希以进行同步（

HashMap

不是线程安全的。请改用

编辑

---

如果您真正的问题是您的代码是否允许您测试任何给定的数据结构是否是线程安全的，那么确实没有可靠的方法可以做到这一点。多线程开发可能会引入大量非常难以检测的错误。数据结构要么设计为线程安全，要么设计为线程安全。

on不起作用，因为所有线程都应该尝试同时将该项添加到哈希中

要做到这一点，您需要使用

[[main]]
CountDownLatch startSignal=新的CountDownLatch（1）；
对于（int i=0；i<10；i++）
{
线程th=新的MyAddingRead（）；
th.Start（）；
}
开始信号倒计时（）；
[[在线程上]]
公共类MyAddingRead扩展线程{
公开募捐
{
开始信号。等待（）；
hash.Add（rn.nextInt，rn.nextInt）；
}
}

此类的javadoc有一个类似（但更复杂）的示例

---

另外，如果您想正确地测试这个问题，请在您的计算机中创建与核心相同数量的线程，每个线程应该执行一个循环，并至少插入几百个项目。如果您尝试只插入10个元素，则很少会遇到并发问题。

a

HashMap

不是同步所以你必须自己做

您可以同步访问：

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

但是，您会错过大部分并发执行

另一个想法是使用

ConcurrentHashMap

：

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

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

ConcurrentMap hash=new ConcurrentHashMap（）；
公共类MyAddingRead扩展线程{
公开募捐{
put（rn.nextInt（），rn.nextInt（））；
}
}

由于更少的阻塞代码，这将提供更高的性能

另一个问题是在这里使用

随机

，这是线程安全的，但也会导致性能低下

---

哪一个解决方案对你的问题是最好的，我不能从你的小伪代码考虑。

<代码>为（int i＝0；i＜11；i++）将循环11次，而不是10次。我想知道您面临的真正问题是什么。创建一个线程只执行一个

散列。put

效率不高。请解释全局以获得更准确的答案。您是否正在尝试确定

散列

是否是线程安全的？确实没有可靠的方法可以做到这一点。Multi-thread开发可能会引入大量极难检测的错误。数据结构要么设计为线程安全，要么不是。您真正想测试什么？同时使用简单的HashMap可能会导致损坏的数据结构，从而在访问时产生无尽的循环！这是真的Java吗？在我看来更像C#我需要测试10个线程写入同一个散列（实际上不是散列而是非常类似的东西我需要证明它是用于写同步的。他没有使用java HashMap。我需要测试它-这是个问题。这个类非常类似于散列映射，但它被认为是线程安全的-我需要证明这是正确的，它确实取决于您正在编写的数据结构。有些是线程安全的，所以me不是。（您可以始终将写操作放在

synchronized

块中，以牺牲性能为代价，确保额外的安全性）

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

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