Java ConcurrentHashMapの使い方|HashMapとの違いと原子的な更新

みかん猫が複数の処理から共有Mapを原子的に更新する考え方を説明するアイキャッチ

複数のスレッドから同じMapを使うときは、値を取得・登録できるだけでなく、同時に更新されても処理の前提が崩れないことが必要です。たとえば「未登録なら追加する」「現在の値に1を足す」という操作は、読み取りと書き込みを別々に行うと競合します。

ConcurrentHashMapは、並行した読み書きに対応するMapです。この記事ではJava SE 21 APIの契約を基準に、HashMapとの使い分け、キー単位の原子的な更新、格納した可変値の扱い、走査や件数取得の注意点を整理します。

目次

ConcurrentHashMapとHashMapの違い

複数スレッドで読み書きするMapに必要な安全性

HashMapは、複数スレッドによる更新を自動で同期しません。同じインスタンスを共有して読み書きするなら、呼び出し側で適切な同期が必要です。ConcurrentHashMapは並行アクセスを想定しており、通常の取得操作は更新操作と並行して実行できます。

ただし、個々のメソッドがスレッドセーフでも、複数の呼び出しを組み合わせた処理まで原子的になるわけではありません。getで取得してからputする間には、別のスレッドによる更新が入り得ます。現在の対応関係を条件に変更する場合は、putIfAbsentやcomputeなど、その目的に合ったメソッドを使います。

単一スレッド・読み取り専用・共有更新で使い分ける

利用状況選択の考え方
単一スレッド内で使うHashMapを基本候補にする
初期化後は読み取りだけを共有する安全に公開し、その後は変更しない条件でHashMapも使える。不変Mapも候補になる
複数スレッドで同じMapを更新するConcurrentHashMapと原子的な更新メソッドを検討する
複数キーをまとめて整合させるMapの選択に加え、ロックやデータ構造などを設計する

読み取り専用の共有では、「初期化が完了した状態をほかのスレッドから正しく参照できること」が条件です。たとえばクラスのstatic初期化で構築し、以後は変更しない構成が考えられます。単に「更新処理を先に呼んだつもり」というだけでは、安全な公開の説明にはなりません。また、Mapを変更しなくても、格納した値を変更するなら、その値の同期は別に必要です。

ConcurrentHashMapの基本的な使い方

生成・put・get・removeの基本操作

基本操作はMapと同じ形で書けます。次は、文字列をキー、Integerを値として使う完結例です。

import java.util.concurrent.ConcurrentHashMap;

public final class BasicMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> scores =
            new ConcurrentHashMap<>();

        scores.put("mikan", 10);
        Integer current = scores.get("mikan");
        Integer removed = scores.remove("mikan");
        Integer missing = scores.get("mikan");

        System.out.println(current);
        System.out.println(removed);
        System.out.println(missing);
    }
}

putは以前の値を、removeは削除した値を返し、対応する値がなければnullを返します。getもキーがなければnullです。この例では一つのスレッドで操作していますが、共有する場合も同じMapインスタンスを各スレッドから参照します。

nullのキーと値を登録できない

ConcurrentHashMapには、nullのキーもnullの値も登録できません。登録しようとするとNullPointerExceptionになります。nullのキーと値を扱えるHashMapから移行するときは、この違いを確認します。

null値が存在しないため、getの戻り値がnullなら、その取得で対応する値が見つからなかったと判断できます。ただし、取得直後も未登録であることまでは保証しません。直後に別スレッドが登録する可能性があるためです。「値がない場合だけ登録する」という条件は、一つの原子的な操作として指定します。

putIfAbsent・computeIfAbsent・computeで原子的に更新する

containsKeyとputに分けると競合する理由

次のような処理は、ConcurrentHashMapを使っていても「未登録の場合だけ追加する」操作にはなりません。以下は競合の説明用の断片です。

if (!map.containsKey(key)) {
    map.put(key, value);
}

スレッドAとBがどちらもcontainsKeyで未登録と判定すると、両方がputへ進めます。Aが登録した値をBが上書きすることもあります。確認と登録の間に割り込める点が問題なので、containsKeyをgetへ置き換えるだけでは解決しません。

putIfAbsentで未登録のキーに値を登録する

putIfAbsentは、指定したキーが未登録の場合だけ値を登録します。未登録の確認と登録が原子的に行われるため、確認後にほかのスレッドが登録した値を無条件で上書きする競合を避けられます。

import java.util.concurrent.ConcurrentHashMap;

public final class PutIfAbsentExample {
    public static void main(String[] args) {
        var labels = new ConcurrentHashMap<String, String>();
        String candidate = "みかん";

        String previous = labels.putIfAbsent("fruit", candidate);
        String selected = previous == null ? candidate : previous;

        System.out.println(selected);
    }
}

戻り値がnullなら、この呼び出しで登録されています。すでに値があれば、その値が返ります。selectedはこの操作で選ばれた値であり、その後もMapに残り続ける保証はありません。

また、putIfAbsentは値の生成を遅延しません。map.putIfAbsent(key, createValue())と書くと、createValueはメソッドへ引数を渡す前に実行されます。登録済みなら生成自体を避けたい場合は、computeIfAbsentが候補になります。

computeIfAbsentで必要なときに値を生成する

computeIfAbsentは、キーが未登録の場合に関数を呼び出して値を計算し、その結果がnullでなければ登録します。登録済みなら、計算せずに既存の値を返します。

import java.util.concurrent.ConcurrentHashMap;

public final class ComputeIfAbsentExample {
    public static void main(String[] args) {
        var lengths = new ConcurrentHashMap<String, Integer>();

        Integer length = lengths.computeIfAbsent(
            "mikan", key -> key.length()
        );

        System.out.println(length);
    }
}

ConcurrentHashMapでは、このメソッド呼び出し全体が原子的に行われます。未登録の場合の関数呼び出しも、その処理に含まれます。ただし、「そのキーについて、アプリケーションの生涯で一度だけ計算する」という保証ではありません。null返却、例外、削除後の呼び出しについては後で整理します。

computeで現在の値を基に更新・削除する

computeは、キーと現在の値を受け取る関数で、次の値を決めます。未登録なら現在の値としてnullが渡されます。たとえば、未登録を0としてカウントを増やす処理を一つの操作にできます。

import java.util.concurrent.ConcurrentHashMap;

public final class ComputeExample {
    public static void main(String[] args) {
        var counts = new ConcurrentHashMap<String, Integer>();

        counts.compute("mikan", (key, current) ->
            current == null ? 1 : current + 1
        );
        counts.compute("mikan", (key, current) ->
            current == null ? 1 : current + 1
        );

        counts.compute("mikan", (key, current) -> null);
    }
}

最後のcomputeは、関数がnullを返すため対応関係を削除します。もともと未登録なら、未登録のままです。これはnull値の登録ではなく、登録しない・削除するという制御です。なお、Integerの加算には範囲の上限があるため、実際のカウンターでは必要な数値範囲も決めます。

原子性の範囲とMap全体の整合性を区別する

メソッド用途主な注意点
putIfAbsent未登録の場合だけ指定値を登録する引数の値生成は遅延しない
computeIfAbsent未登録の場合だけ関数で値を生成するnullなら登録しない
compute現在の値を基に登録・更新・削除するnull返却は削除または未登録の維持になる

ここで扱う原子性は、対象キーの対応関係について、条件判定や計算と更新を一つの操作として行う保証です。別のキーへの操作や、関数内で実行した外部処理まで、一つのトランザクションになるわけではありません。また、この説明はConcurrentHashMapの契約であり、MapやConcurrentMapのすべての実装へそのまま一般化できません。

mapping functionを短く保つ理由と注意点

長い計算や外部I/Oが更新の待機に与える影響

computeIfAbsentへ渡す値生成関数をmapping function、computeへ渡す再計算用の関数をremapping functionと呼びます。いずれも短く、単純な処理に保つことが大切です。計算中は、ほかのスレッドによる一部の更新操作が待機する可能性があります。

関数内で時間のかかるHTTP通信やDBアクセスをすると、外部サービスの待ち時間がMapの更新待ちにも影響します。別キーなら必ず影響しない、とも考えないでください。待機の範囲を内部実装の特定のロック方式に依存して設計しないことが重要です。

生成処理をMapの外へ移し、最後にputIfAbsentで登録する方法なら、関数内の長い処理を避けられます。ただし、複数スレッドが同じ値を重複して生成する可能性があります。重複生成を許容できるか、生成失敗をどう扱うかまで含めて選びます。

関数内で同じMapを更新しない

computeIfAbsentやcomputeへ渡す関数の中では、同じMapに対して別の更新を行わないようにします。同じキーへの再帰呼び出しだけでなく、別キーのputやcomputeなども避けます。必要な計算結果を返し、対象キーへの反映は呼び出しているメソッドに任せます。

終了できなくなる再帰的な更新が検出されると、IllegalStateExceptionになります。ただし、例外による検出を安全策として当てにせず、関数内から同じMapを更新しない構成にします。

nullの返却・例外・削除後の再計算を扱う

computeIfAbsentの関数がnullを返すと、値は登録されません。次の呼び出しでも未登録なら、関数が再び実行されます。関数が非チェック例外を送出した場合も、その例外が呼び出し元へ伝わり、その呼び出しによる登録は行われません。

一度登録できた値でも、removeやcomputeなどで削除された後は、再び計算され得ます。したがって、computeIfAbsentを「外部APIへの通知を永久に一度だけ実行する仕組み」として使うことはできません。

computeの関数が非チェック例外を送出した場合、対応関係は変更されません。ただし、関数内で既存の可変オブジェクトを書き換えたり、外部へ通知したりした副作用まで元に戻るわけではありません。関数は、受け取った値から次の値を計算する処理に寄せます。

Mapの安全性と格納した可変オブジェクトの安全性は別

computeIfAbsentで取得したArrayListの更新も設計する

ConcurrentHashMapが安全に管理するのは、キーと値の対応関係です。値として格納したArrayListまで、自動でスレッドセーフになるわけではありません。次は、並行更新を避けたい書き方の断片です。

groups.computeIfAbsent(key, k -> new ArrayList<>())
      .add(value);

このaddは、computeIfAbsentが返った後に実行されます。複数スレッドが同じArrayListを受け取れば、その内部を同時に変更してしまいます。リストの生成・登録が原子的であることと、取得後のリスト操作が安全であることは別です。

可変値の更新をcompute内へ移すだけでも、Mapの外からその値を読む・変更する処理があれば安全性は完成しません。値へのすべてのアクセスと、削除・置き換えのルールを合わせて設計します。

不変値への置き換えやスレッドセーフな値を選ぶ

一つの方法は、格納済みのリストを変更せず、新しいリストを作って置き換えることです。次の例はStringを要素に使い、変更できないリストをMapへ格納します。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

public final class ImmutableValueExample {
    private final ConcurrentHashMap<String, List<String>> groups =
        new ConcurrentHashMap<>();

    public void add(String group, String member) {
        groups.compute(group, (key, current) -> {
            var next = new ArrayList<String>();
            if (current != null) {
                next.addAll(current);
            }
            next.add(member);
            return List.copyOf(next);
        });
    }

    public List<String> members(String group) {
        return groups.getOrDefault(group, List.of());
    }

    public static void main(String[] args) {
        var example = new ImmutableValueExample();
        example.add("editors", "mikan");
        System.out.println(example.members("editors"));
    }
}

取得済みのリストは、後の追加処理で変更されません。一方、更新のたびにコピーするため、大きなリストや更新頻度の高い用途ではコストを評価します。List.copyOfは要素そのものを深くコピーするものではないため、要素が可変ならその扱いも必要です。また、null要素は許可されません。

用途に応じて、値にConcurrentLinkedQueueやAtomicLongなどを使う方法もあります。ただし、値の操作がスレッドセーフでも、Mapから削除された値への参照を別スレッドが持ち続ける場合があります。削除や置き換えと値の更新を一つの条件で扱う必要があるなら、そのライフサイクルまで設計します。

iteratorとsizeを使うときの注意点

weakly consistentな走査はスナップショットではない

ConcurrentHashMapのiteratorは、weakly consistentと呼ばれる性質を持ちます。更新と並行して走査でき、並行更新を理由にConcurrentModificationExceptionを送出しません。ただし、Map全体のある一瞬を固定したスナップショットではありません。

走査中の更新が反映される場合も、反映されない場合もあります。キーの順序も保証されないため、更新中のMapを走査して「この時点の全件」を厳密に集計する用途には、そのまま使えません。別のMapへコピーしても、コピー元が更新中なら、取得過程全体が原子的になるわけではありません。

厳密な一覧が必要なら、更新を止める共通の同期手順や、不変の状態全体を差し替える設計などを検討します。また、一つのiteratorを複数スレッドから同時に操作してよいという意味でもありません。

更新中のsizeやisEmptyを処理の可否判定に使わない

更新と並行したsizeやisEmptyの結果は、一時的な状態を表します。取得直後に状態が変わるため、監視や表示の参考値と、処理を許可するための厳密な条件を分けます。

たとえば「sizeが100未満なら登録する」と書いても、複数スレッドが同時に条件を満たし、上限を超えて登録できます。isEmptyがfalseだったとしても、その後のgetで値が得られる保証はありません。件数上限の厳守には共通のロックなどを使い、個別キーの条件判定には原子的なメソッドを使います。

ConcurrentHashMapの適用範囲と性能の判断

複数キーの一括更新やJVMをまたぐ整合性は別に設計する

キーAを減らしてキーBを増やす処理を、二つのcomputeで実行しても、全体が一つのトランザクションにはなりません。途中でほかのスレッドが読むと、片方だけ更新された状態を観測できます。putAllやclearも、Map全体を一度に切り替える操作として扱わないようにします。

複数キーで守る条件があるなら、関係する読み書きすべてが従う共通のロックを設ける、関連する値を一つの不変オブジェクトへまとめる、といった方法を検討します。Mapの外側でsynchronizedを使っても、ほかのアクセスが同じロックに従わなければ、業務上の条件は守れません。

また、ConcurrentHashMapが共有する状態は、そのインスタンスを保持するJVM内にあります。複数のアプリケーションインスタンスやJVMをまたぐ重複防止、残高、在庫などの整合性は、DBのトランザクションや一意制約など、共有先の仕組みで設計します。

仮想スレッドでも共有Mapの競合は設計が必要

仮想スレッドを使っても、containsKeyとputの間に別の処理が入る問題や、同じ可変値を同時更新する問題は残ります。タスクの実行方式と、共有状態の更新方法は別に選びます。多数のタスクが特定のキーへ集中する場合は、その更新の競合も確認対象です。

仮想スレッドの基本と、外部I/Oを扱う際の資源制御については、次の記事で整理しています。

性能は読み書きの比率・キーの偏り・値の生成コストで評価する

ConcurrentHashMapへ変更すれば、どの処理でも速くなるわけではありません。評価では、同じ安全性の要件を満たす構成同士を比べます。同期のないHashMapを並行更新する構成は、正しさを満たす比較対象にはなりません。

観点確認する内容
読み書きの比率取得中心か、登録・更新・削除が多いか
キーの偏り更新が一部のキーへ集中するか
値の生成・更新コスト関数内の計算時間、コピー量、外部I/Oの有無
データ量登録件数、値の大きさ、増減、メモリ使用量
並行度と応答同時実行数、処理件数、応答時間の分布、待機
比較条件JDKの配布元・更新版、機器、ウォームアップ、測定時間

Map操作だけのコストと、値の生成や業務処理を含めたコストを分けると、改善対象を判断しやすくなります。特定の内部ロック方式や、計測していない性能差を前提にせず、実際の読み書きとキー分布に近い条件で評価します。

まとめ

ConcurrentHashMapは、複数スレッドから共有Mapを読み書きするときの選択肢です。未登録なら登録する処理にはputIfAbsent、必要なときだけ値を生成する処理にはcomputeIfAbsent、現在の値を基に更新・削除する処理にはcomputeを使い、条件判定と更新を分割しないようにします。

関数内の処理は短く保ち、同じMapを更新しないこと、null返却や例外の扱いを決めることが重要です。Mapの原子性は、可変値の内部操作や複数キーのトランザクションまで広がりません。走査とsizeも厳密なスナップショットとして扱わず、必要な整合性と性能を分けて設計してください。

API契約の参照先は、Java SE 21のConcurrentHashMap APIと、HashMap APIです。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

CAPTCHA


目次