1書き込みパフォーマンス、100万データ、100スレッドを開いて書き込みます
1.1ハッシュテーブル
パブリッククラスT_Hashtable {
static Hashtable <UUID、UUID> m = new Hashtable <>（）;
static int count = Constants.COUNT;
静的UUID []キー=新しいUUID [カウント];
静的UUID []値=新しいUUID [カウント];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
静的{
for（int i = 0; i <count; i ++）{
keys [i] = UUID.randomUUID（）;
values [i] = UUID.randomUUID（）;
}
}
静的クラスMyThreadはThread {を拡張します
int start;
intギャップ=カウント/ THREAD_COUNT;
public MyThread（int start）{
this.start = start;
}
@オーバーライド
public void run（）{
for（int i = start; i <start + gap; i ++）{
m.put（keys [i]、values [i]）;
}
}
}
public static void main（String [] args）{
ロングスタート= System.currentTimeMillis（）;
スレッド[]スレッド=新しいスレッド[THREAD_COUNT];
for（int i = 0; i <threads.length; i ++）{
スレッド[i] = new MyThread（i *（count / THREAD_COUNT））;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
ロングエンド= System.currentTimeMillis（）;
System.out.println（ "時間" +（終了-開始））;
System.out.println（ "大小：" + m.size（））;
// ------------------------------
start = System.currentTimeMillis（）;
for（int i = 0; i <threads.length; i ++）{
スレッド[i] =新しいスレッド（（）-> {
for（int j = 0; j <10000000; j ++）{
m.get（keys [10]）;
}
}）;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
end = System.currentTimeMillis（）;
System.out.println（end-start）;
}
}
その結果、時間がかかります。
1.2 HashMap
パブリッククラスT02_TestHashMap {
static HashMap <UUID、UUID> m = new HashMap <>（）;
static int count = Constants.COUNT;
静的UUID []キー=新しいUUID [カウント];
静的UUID []値=新しいUUID [カウント];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
静的{
for（int i = 0; i <count; i ++）{
keys [i] = UUID.randomUUID（）;
values [i] = UUID.randomUUID（）;
}
}
静的クラスMyThreadはThread {を拡張します
int start;
intギャップ=カウント/ THREAD_COUNT;
public MyThread（int start）{
this.start = start;
}
@オーバーライド
public void run（）{
for（int i = start; i <start + gap; i ++）{
m.put（keys [i]、values [i]）;
}
}
}
public static void main（String [] args）{
ロングスタート= System.currentTimeMillis（）;
スレッド[]スレッド=新しいスレッド[THREAD_COUNT];
for（int i = 0; i <threads.length; i ++）{
スレッド[i] =
new MyThread（i *（count / THREAD_COUNT））;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
ロングエンド= System.currentTimeMillis（）;
System.out.println（end-start）;
System.out.println（m.size（））;
}
}
結果：時間がかかる
1.3 Collections.synchronizedMap（new HashMap <UUID、UUID>（））
パブリッククラスT_SynchronizedHashMap {
static Map <UUID、UUID> m = Collections.synchronizedMap（new HashMap <UUID、UUID>（））;
static int count = Constants.COUNT;
静的UUID []キー=新しいUUID [カウント];
静的UUID []値=新しいUUID [カウント];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
静的{
for（int i = 0; i <count; i ++）{
keys [i] = UUID.randomUUID（）;
values [i] = UUID.randomUUID（）;
}
}
静的クラスMyThreadはThread {を拡張します
int start;
intギャップ=カウント/ THREAD_COUNT;
public MyThread（int start）{
this.start = start;
}
@オーバーライド
public void run（）{
for（int i = start; i <start + gap; i ++）{
m.put（keys [i]、values [i]）;
}
}
}
public static void main（String [] args）{
ロングスタート= System.currentTimeMillis（）;
スレッド[]スレッド=新しいスレッド[THREAD_COUNT];
for（int i = 0; i <threads.length; i ++）{
スレッド[i] = new MyThread（i *（count / THREAD_COUNT））;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
ロングエンド= System.currentTimeMillis（）;
System.out.println（end-start）;
System.out.println（m.size（））;
// ----------------------------
start = System.currentTimeMillis（）;
for（int i = 0; i <threads.length; i ++）{
スレッド[i] =新しいスレッド（（）-> {
for（int j = 0; j <10000000; j ++）{
m.get（keys [10]）;
}
}）;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
end = System.currentTimeMillis（）;
System.out.println（end-start）;
}
}
時間がかかる：
1.4 ConcurrentHashMap
パブリッククラスT_ConcurrentHashMap {
static Map <UUID、UUID> m = new ConcurrentHashMap <>（）;
static int count = Constants.COUNT;
静的UUID []キー=新しいUUID [カウント];
静的UUID []値=新しいUUID [カウント];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
静的{
for（int i = 0; i <count; i ++）{
keys [i] = UUID.randomUUID（）;
values [i] = UUID.randomUUID（）;
}
}
静的クラスMyThreadはThread {を拡張します
int start;
intギャップ=カウント/ THREAD_COUNT;
public MyThread（int start）{
this.start = start;
}
@オーバーライド
public void run（）{
for（int i = start; i <start + gap; i ++）{
m.put（keys [i]、values [i]）;
}
}
}
public static void main（String [] args）{
ロングスタート= System.currentTimeMillis（）;
スレッド[]スレッド=新しいスレッド[THREAD_COUNT];
for（int i = 0; i <threads.length; i ++）{
スレッド[i] =新しいMyThread（i *（count / THREAD_COUNT））;
}
for（Thread t：threads）{
t.start（）;
}
for（Thread t：threads）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
ロングエンド= System.currentTimeMillis（）;
System.out.println（end-start）;
System.out.println（m.size（））;
// --------------------------------------------
start = System.currentTimeMillis（）;
for（int i = 0; i <threads.length; i ++）{
スレッド[i] =新しいスレッド（（）-> {
for（int j = 0; j <10000000; j ++）{
m.get（keys [10]）;
}
}）;
}
for（スレッドt：スレッド）{
t.start（）;
}
for（スレッドt：スレッド）{
{を試してください
t.join（）;
} catch（InterruptedException e）{
e.printStackTrace（）;
}
}
end = System.currentTimeMillis（）;
System.out.println（end-start）;
}
}
時間がかかる：
2読書パフォーマンス
ハッシュ表
Collections.synchronizedMap（new HashMap <UUID、UUID>（））
ConcurrentHashMap
結論として：
1 HashTableの最下層は、同期されたロックによってスレッドセーフを実現するため、パフォーマンスは比較的低くなります。
2 HashMapスレッドは安全ではありません。パフォーマンスは、HashTableと比較して一定の改善があります。
3 Collections.synchronizedMap（new HashMap <UUID、UUID>（））、最下層も同期をロックすることでスレッドセーフであるため、パフォーマンスは比較的低くなります
4 ConcurrentHashMapは、書き込みパフォーマンスにおいてHashTableよりも高速ではありません。その基礎となる複雑なデータ構造がロックセグメンテーションを使用しているため、Collections.synchronizedMap（）はロックしますが、データの読み取りは非常に高速で、HashTableおよびCollections .synchronizedMap（）よりも高速です。
ConcurrentHashMapのデータ構造については後で説明します。