ヘッダーをスキップ
Oracle® Coherenceクライアント・ガイド
リリース3.7.1
B65027-01
  ドキュメント・ライブラリへ移動
ライブラリ
製品リストへ移動
製品
目次へ移動
目次

前
 
次
 

14 キャッシュ・イベントの使用方法(C++)

Coherenceでは、キャッシュ・イベントが提供されています。変更が実際にはクラスタ内のどこで発生していても、とても簡単な方法で必要なイベントを必要なときに受信できます。

この章の内容は次のとおりです。

14.1 リスナー・インタフェースおよびイベント・オブジェクト

イベント・モデルには、すべてのリスナーで拡張する必要があるEventListenerインタフェースがあります。Coherenceには、MapListenerインタフェースが用意されており、これによりCoherenceキャッシュのデータが追加、変更または削除されたときにアプリケーション・ロジックでイベントを受信できます。例14-1に、MapListener APIの一部を示します。

例14-1 coherence::util::MapListenerクラス・ファイルからの抜粋

class MapListener
    : public interface_spec<MapListener,
        implements<EventListener> >
    {
    // ----- handle definitions ---------------------------------------------

    public:
        /**
        * Handle definition.
        */
        typedef TypedHandle<MapListener> Handle;
 
        /**
        * View definition.
        */
        typedef TypedHandle<const MapListener> View;
 
        /**
        * MapEvent View definition.
        */
        typedef TypedHandle<const MapEvent> MapEventView;
  
 
    // ----- MapListener interface ------------------------------------------
 
    public:
        /**
        * Invoked when a map entry has been inserted.
        *
        * @param vEvent  the MapEvent carrying the insert information
        */
        virtual void entryInserted(MapEventView vEvent) = 0;
 
        /**
        * Invoked when a map entry has been updated.
        *
        * @param vEvent  the MapEvent carrying the update information
        */
        virtual void entryUpdated(MapEventView vEvent) = 0;
 
        /**
        * Invoked when a map entry has been removed.
        *
        * @param vEvent  the MapEvent carrying the delete information
        */
        virtual void entryDeleted(MapEventView vEvent) = 0;
    };

MapListenerインタフェースを実装するアプリケーション・オブジェクトは、アプリケーションのMapListener実装のインスタンスをaddMapListener()メソッドに渡すことで、ObservableMapインタフェースを実装する任意のCoherenceキャッシュまたはクラスからイベントにサインアップできます。

MapListenerに渡されるMapEventオブジェクトは、イベントの発生元になったソース(ObservableMap)、イベントに関連付けられたID(キー)、そのIDに対するアクション(挿入、更新、削除)、古い値と新しい値など、発生したイベントについて必要なすべての情報を保持します。例14-2に、MapEvent APIの一部を示します。

例14-2 coherence::util::MapEventからの抜粋

class COH_EXPORT MapEvent
    : public class_spec<MapEvent,
        extends<EventObject> >
     {
     friend class factory<MapEvent>;
 
      
     // ----- MapEvent interface ---------------------------------------------
 
 public:        /**        * Return an ObservableMap object on which this event has actually        * occurred.        *        * @return an ObservableMap object        */        virtual TypedHandle<ObservableMap> getMap() const;        /**        * Return this event's id. The event id is an entry_*        * enumerated constants.        *        * @return an id        */        virtual int32_t getId() const;        /**        * Return a key associated with this event.        *        * @return a key        */        virtual Object::View getKey() const;        /**        * Return an old value associated with this event.        * <p>        * The old value represents a value deleted from or updated in a map.        * It is always NULL for "insert" notifications.        *        * @return an old value        */        virtual Object::View getOldValue() const;        /**        * Return a new value associated with this event.        * <p>        * The new value represents a new value inserted into or updated in        * a map. It is always NULL for "delete" notifications.        *        * @return a new value        */        virtual Object::View getNewValue() const;
 
     // ----- Objectinterface -----------------------------------------------
 
     public:
         /**
         * {@inheritDoc}
         */
         virtual void toStream(std::ostream& out) const;
 
 
     // ----- helper methods -------------------------------------------------
 
 public:        /**        * Dispatch this event to the specified listeners collection.        * <p>        * This call is equivalent to        * <pre>        *   dispatch(listeners, true);        * </pre>        *        * @param vListeners the listeners collection        *        * @throws ClassCastException if any of the targets is not        *         an instance of MapListener interface        */        virtual void dispatch(Listeners::View vListeners) const;        /**        * Dispatch this event to the specified listeners collection.        *        * @param vListeners the listeners collection        * @param fStrict    if true then any Run time Exception thrown by event        *                   handlers stops all further event processing and        *                   the exception is re-thrown; if false then all        *                   exceptions are logged and the process continues        *        * @throws ClassCastException if any of the targets is not        *         an instance of MapListener interface        */        virtual void dispatch(Listeners::View vListeners,                bool fStrict) const;        /**        * Dispatch this event to the specified MapListener.        *        * @param hListener  the listener        */        virtual void dispatch(TypedHandle<MapListener> hListener) const;        /**        * Convert an event ID into a human-readable string.        *        * @param nId  an event ID, an entry_* enumerated values        *        * @return a corresponding human-readable string, for example        *         "inserted"        */        static String::View getDescription(int32_t nId);        using Describable::getDescription;
 
      // ----- Describable interface ------------------------------------------
 
 public:
        /**
        * {@inheritDoc}
        */
        virtual void outputDescription(std::ostream& out) const;

     // ----- constants ------------------------------------------------------
 
 public:
        /**
        * This event indicates that an entry has been added to the map.
        */
        static const int32_t entry_inserted = 1;
 
        /**
        * This event indicates that an entry has been updated in the map.
        */
        static const int32_t entry_updated  = 2;
 
        /**
        * This event indicates that an entry has been removed from the map.
        */
        static const int32_t entry_deleted  = 3;
     };

14.2 イベントをサポートするキャッシュとクラス

すべてのCoherenceキャッシュには、ObservableMapが実装されます。実際に、すべてのCoherenceキャッシュで実装されるNamedCacheインタフェースは、ObservableMapインタフェースを拡張します。つまり、キャッシュが、ローカル、パーティション、ニア、レプリケーションであるかどうか、また、リードスルー、ライトスルー、ライトビハインド、オーバーフロー、ディスク記憶域などを使用しているかどうかに関係なく、アプリケーションはサインアップして任意のキャッシュからイベントを受信できます。


注意:

キャッシュ・トポロジやサーバーの数に関係なく、また他のサーバーが変更している場合でも、これらのイベントはアプリケーションのリスナーに配信されます。

Coherenceキャッシュ(Coherenceキャッシュ・ファクトリを介して取得されたオブジェクト)に加えて、次のように、Coherenceでサポートされる他のいくつかのクラスでもObservableMapインタフェースが実装されます。

公開されている実装クラスの一覧は、Coherence APIの「ObservableMap」を参照してください。

14.3 すべてのイベントのサインアップ

イベントにサインアップするには、MapListenerインタフェースを実装するオブジェクトをObservableMapaddMapListenerメソッドに渡します。

例14-3 ObservableMapのメソッド

virtual void addKeyListener(MapListener::Handle hListener, Object::View vKey, bool fLite) = 0;
virtual void removeKeyListener(MapListener::Handle hListener, Object::View vKey) = 0;
virtual void addFilterListener(MapListener::Handle hListener, Filter::View vFilter = NULL, bool fLite = false) = 0;
virtual void removeFilterListener(MapListener::Handle hListener, Filter::View vFilter = NULL) = 0;

MapListener実装のサンプルを作成してみましょう。

例14-4 MapListener実装のサンプル

#include "coherence/util/MapEvent.hpp"
#include "coherence/util/MapListener.hpp"

#include <iostream>

using coherence::util::MapEvent;
using coherence::util::MapListener;
using namespace std;

/**
* A MapListener implementation that prints each event as it receives
* them.
*/
class EventPrinter 
    : public class_spec<EventPrinter,
        extends<Object>,
        implements<MapListener> >
    {    
    friend class factory<EventPrinter>;

    public:
        virtual void entryInserted(MapEventView vEvent)
            {
            cout << vEvent << endl;
            }

        virtual void entryUpdated(MapEventView vEvent)
            {
            cout << vEvent << endl;
            }

        virtual void entryDeleted(MapEventView vEvent)
            {
            cout << vEvent << endl;
            }
    };

この実装を使用すると、任意のキャッシュからすべてのイベントを簡単に出力できます(すべてのキャッシュでObservableMapインタフェースが実装されているため)。

例14-5 イベントの出力

NamedCache::Handle hCache;
...
hCache->addFilterListener(EventPrinter::create());

ただし、後でリスナーを削除できるように、リスナーへの参照を保持する必要があります。

例14-6 リスナーへの参照の保持

MapListener::Handle hListener = EventPrinter::create();
hCache->addFilterListener(hListener);
m_hListener = hListener; // store the listener in a member field

後でリスナーを削除するには、次のように処理します。

例14-7 リスナーへの参照の削除

MapListener::Handle hListener = m_hListener;
if (hListener != NULL)
    {
    hCache->removeFilterListener(hListener);
    m_hListener = NULL; // clean up the listener field
    }

ObservableMapインタフェースの各add*Listenerメソッドには、対応するremove*Listenerメソッドがあります。リスナーを削除するには、そのリスナーの追加に使用したadd*Listenerメソッドに対応するremove*Listenerメソッドを使用します。

14.4 MultiplexingMapListener

MapListenerの作成に役立つもう1つのベース・クラスは、MultiplexingMapListenerです。これは、すべてのイベントを1つのメソッドにルーティングして処理します。例14-8に、EventPrinterの例を簡略化したものを示します。

例14-8 MultiplexingMapListenerを使用したイベントのルーティング

#include "coherence/util/MultiplexingMapListener.hpp"

#include <iostream>

using coherence::util::MultiplexingMapListener;


class EventPrinter 
    : public class_spec<EventPrinter,
        extends<MultiplexingMapListener> >
    {
    public:
        virtual void onMapEvent(MapEventView vEvent)
            {
            std::cout << vEvent << std::endl;
            }
    };

14.5 キャッシュ用のMapListenerの構成

特定のキャッシュにリスナーを常駐させる必要がある場合、<listener>要素を使用して、それをキャッシュ構成に配置します。キャッシュ構成の際に、リスナーは自動的に追加されます。

14.6 特定のIDのイベントのサインアップ

特定のID(キー)に対して発生したイベントのサインアップは非常に簡単です。例14-9のC++コードでは、Integerキー5に対して発生したすべてのイベントが出力されます。

例14-9 指定したIntegerキーに対して発生したイベントの出力

hCache->addKeyListener(EventPrinter::create(), Integer32::create(5), false);

例14-10のコードでは、Integerキー5が挿入または更新された場合にのみイベントがトリガーされます。

例14-10 指定したIntegerキーの値に対するイベントのトリガー

for (int32_t i = 0; i < 10; ++i)
    {
    Integer32::View vKey   = Integer32::create(i);
    Integer32::View vValue = vKey;
    hCache->put(vKey, vValue);
    }

14.7 イベントのフィルタリング

特定のキーのリスニングと同様に、特定のイベントをリスニングすることもできます。例14-11では、削除イベントのみを受信できるフィルタを指定したリスナーが、キャッシュに追加されます。

例14-11 削除されたイベントのみを許可するフィルタを指定したリスナーの追加

// Filters used with partitioned caches must implement coherence::io::pof::PortableObject

#include "coherence/io/pof/PofReader.hpp"
#include "coherence/io/pof/PofWriter.hpp"
#include "coherence/io/pof/PortableObject.hpp"
#include "coherence/util/Filter.hpp"
#include "coherence/util/MapEvent.hpp"

using coherence::io::pof::PofReader;
using coherence::io::pof::PofWriter;
using coherence::io::pof::PortableObject;
using coherence::util::Filter;
using coherence::util::MapEvent;

class DeletedFilter
    : public class_spec<DeletedFilter,
        extends<Object>,
        implements<Filter, PortableObject> >
    {
    public:
        // Filter interface        virtual bool evaluate(Object::View v) const
            {
            MapEvent::View vEvt = cast<MapEvent::View>(v);
            return MapEvent::entry_deleted == vEvt->getId();
            }

        // PortableObject interface        virtual void readExternal(PofReader::Handle hIn)
            {
            }

        virtual void writeExternal(PofWriter::Handle hOut) const
            {
            }
    };

hCache->addFilterListener(EventPrinter::create(), DeletedFilter::create(), false);

たとえば、次の一連のコールが実行されたとします。

例14-12 キャッシュに対するデータの挿入および削除

cache::put(String::create("hello"), String::create("world"));
cache::put(String::create("hello"), String::create("again"));
cache::remove(String::create("hello"));

次のような結果になります。

CacheEvent{LocalCache deleted: key=hello, value=again}

詳細は、「応用: 問合せのリスニング」を参照してください。

イベントのフィルタリングとキャッシュされたデータのフィルタリングの比較

問合せのFilterを作成する場合、Filterのevaluateメソッドに渡すオブジェクトはキャッシュからの値になります。または、FilterEntryFilterインタフェースを実装する場合は、キャッシュからのMap::Entry全体になります。MapListenerのイベントをフィルタリングするFilterを作成する場合、Filterevaluateメソッドに渡すオブジェクトは常にMapEvent型になります。

問合せフィルタを使用してキャッシュ・イベントをリスニングする方法の詳細は、「応用: 問合せのリスニング」を参照してください。

14.8 Liteイベント

デフォルトでは、イベントの一部として古い値と新しい値が両方とも提供されます。次の例があります。

例14-13 値の挿入、更新、削除

MapListener::Handle hListener = EventPrinter::create();
// add listener with the default"lite" value of falsehCache->addFilterListener(hListener);

// insert a 1KB value
String::View vKey = String::create("test");
hCache->put(vKey, Array<octet_t>::create(1024));

// update with a 2KB value
hCache->put(vKey, Array<octet_t>::create(2048));

// remove the value
hCache->remove(vKey);

このコードを実行すると、挿入イベントには新しい1KBの値、更新イベントには古い1KBの値と新しい2KBの値、削除イベントには削除された2KBの値がそれぞれ保持されます。

アプリケーションでイベントに古い値と新しい値を両方とも含める必要がない場合、Liteイベントのみをリクエストして、そのように指定することができます。リスナーの追加時にLiteイベントをリクエストするには、追加のブール・パラメータfLiteを使用するaddFilterListenerメソッドとaddKeyListenerメソッドのいずれかを使用できます。前述の例の場合、変更は次の箇所のみです。

例14-14 Liteイベントのみのリクエスト

cache->addFilterListener(hListener, (Filter::View) NULL, true);

注意:

Liteイベントの古い値と新しい値は、NULLにすることができます。ただし、Liteイベントをリクエストしても、イベントの生成と配信に余分な負荷がかからない場合は、古い値と新しい値が含まれることがあります。つまり、MapListener受信Liteイベントを要求することは、MapListenerがイベントについて古い値と新しい値の情報を必要としないことを単純にシステムに通知することになります。

14.9 応用: 問合せのリスニング

すべてのCoherenceキャッシュはどの基準による問合せもサポートしています。アプリケーションでキャッシュからのデータを問い合せる場合、その結果はID(keySet)のセットまたはID/値のペア(entrySet)のセットとしてのポイント・イン・タイム・スナップショットになります。結果セットの内容を判断するメカニズムは、フィルタリングと呼ばれ、これによりアプリケーションの開発者は豊富な既定のフィルタ(equals、less-than、like、betweenなど)を使用してどのように複雑な問合せも構築でき、また独自のカスタム・フィルタ(XPathなど)を提供できます。

キャッシュの問合せに使用するフィルタと同じフィルタを、キャッシュからのイベントのリスニングに使用します。たとえば、トレーディング・システムにおいて、特定のトレーダーの未決済Orderオブジェクトをすべて問い合せることができます。


注意:

クラスタでの問合せの実行: 例14-15では、coherence::util::extractor::ReflectionExtractorクラスが使用されています。C++クライアントではリフレクションがサポートされませんが、クラスタ内で実行される問合せにはReflectionExtractorを使用できます。この場合、ReflectionExtractorは、問合せを実行するクラスタに、必要な抽出情報を渡すのみです。ReflectionExtractorがクライアントでデータを抽出することになる場合(値をローカルにキャッシュするときのContinuousQueryCacheなど)は、ReflectionExtractorの使用はサポートされません。この場合は、カスタム・エクストラクタを用意する必要があります。

例14-15 キャッシュ・イベントのフィルタリング

NamedCache::Handle hMapTrades = ...
Filter::Handle hFilter = AndFilter::create(
        EqualsFilter::create(ReflectionExtractor::create("getTrader"), vTraderId),
        EqualsFilter::create(ReflectionExtractor::create("getStatus"), Status::OPEN));
Set::View vSetOpenTrades = hMapTrades->entrySet(hFilter);

そのトレーダーが新しいポジションを建てた、そのトレーダーがポジションを決済した、トレーダー間でポジションを付け替えた、という情報を受信するために、アプリケーションで同じフィルタを使用できます。

例14-16 特化されたイベントのフィルタリング

// receive events for all trade IDs that this trader is interested in
hMapTrades->addFilterListener(hListener, MapEventFilter::create(hFilter), true);

MapEventFilterは、問合せフィルタをイベント・フィルタに変換します。


注意:

イベントのフィルタリングとキャッシュされたデータのフィルタリングの比較: 問合せのFilterを作成する場合、Filterのevaluateメソッドに渡すオブジェクトはキャッシュからの値になります。または、FilterEntryFilterインタフェースを実装する場合は、キャッシュからのMap::Entry全体になります。MapListenerのイベントをフィルタリングするFilterを作成する場合、Filterevaluateメソッドに渡すオブジェクトは常にMapEvent型になります。

MapEventFilterは、問合せに使用するFilterMapListenerのイベントのフィルタリングに使用するFilterに変換します。つまり、MapEventFilterはキャッシュを問い合せるFilterから作成されますが、作成されたMapEventFilterは、問合せFilterが期待するオブジェクトに変換することによってMapEventオブジェクトを評価するフィルタになります。


MapEventFilterには、いくつもの非常に強力なオプションがあります。これにより、アプリケーション・リスナーは特に関心のあるイベントのみを受信できます。スケーラビリティとパフォーマンスの観点からさらに重要なこととして、必要なイベントのみがネットワーク上で通信されるため、それらの特定イベントを対象とするサーバーとクライアントにのみ配信されます。次に例を示します。

例14-17 ネットワークを介した、特化されたイベントのみの伝達

// receive all events for all trades that this trader is interested in
int32_t nMask = MapEventFilter::e_all;
hMapTrades->addFilterListener(hListener, MapEventFilter::create(nMask, hFilter), true);

// receive events for all this trader's trades that are closed or
// re-assigned to a different trader
nMask = MapEventFilter::e_updated_left | MapEventFilter::e_deleted;
hMapTrades->addFilterListener(hListener, MapEventFilter::create(nMask, hFilter), true);

// receive events for all trades as they are assigned to this trader
nMask = MapEventFilter::e_inserted | MapEventFilter::e_updated_entered;
hMapTrades->addFilterListener(hListener, MapEventFilter::create(nMask, hFilter), true);

// receive events only for new trades assigned to this trader
nMask = MapEventFilter::e_inserted;
hMapTrades->addFilterListener(hListener, MapEventFilter::create(nMask, hFilter), true);

サポートされる各種オプションの詳細は、MapEventFilterのAPIドキュメントを参照してください。

14.10 応用: 統合イベント

イベントは通常、キャッシュで発生している変更を反映します。たとえば、あるサーバーがキャッシュ内の1つのエントリを変更し、別のサーバーがキャッシュに複数のアイテムを追加し、3つ目のサーバーが同じキャッシュから1つのアイテムを削除している間に、クラスタ内の各サーバーで50個のスレッドが同じキャッシュのデータにアクセスすることがあります。すべての変更操作によりイベントが生成されますが、それをクラスタ内の任意のサーバーで受信するように選択できます。これらの操作をクライアント・アクションと呼び、そのイベントは、クライアントにディスパッチされた状態にあります(この場合の「クライアント」は実際には「サーバー」)。これはCoherenceクラスタなどの、真のpeer-to-peerアーキテクチャでは自然の概念です。いずれのピアもクライアントでありサーバーでもあるので、他のピアからサービスを受け、他のピアにサービスを提供します。一般的なJava Enterpriseアプリケーションでは、ピアはアプリケーションのコンテナとして動作するアプリケーション・サーバー・インスタンスで、クライアントは直接キャッシュに対してアクセスおよび変更を行い、キャッシュからのイベントをリスニングするアプリケーションの一部です。

イベントの中には、キャッシュ内部で起動されるものもあります。多くの例がありますが、最も一般的なケースは次のとおりです。

これらは変更の各例ですが、変更とはキャッシュ内部での自然な(通常は自動的な)各操作を表します。これらのイベントを統合イベントと呼びます。

必要に応じて、アプリケーションはイベントに問い合せて、それがクライアントに起因するイベントか、または統合イベントかを区別できます。この情報は、CacheEventというMapEventのサブクラスで保持されます。前述のEventPrinterの例を使用して、統合イベントのみを出力できます。

例14-18 クライアントに起因するイベントと統合イベントの区別

class EventPrinter
    : public class_spec<EventPrinter,
        extends<MultiplexingMapListener> >
    {
    friend class factory<EventPrinter>;

    public:
        void onMapEvent(MapEvent::View vEvt)
            {
            if (instanceof<CacheEvent::View>(vEvt) &&
                (cast<CacheEvent::View>(vEvt)->isSynthetic()))
                {
                std::cout << vEvt;
                }
            }
    };

この機能の詳細は、CacheEventのAPIドキュメントを参照してください。

14.11 応用: バッキング・マップ・イベント

Coherenceキャッシュのイベントをリスニングし、データに関して分散、パーティション、レプリケーション、ニア・キャッシュ、連続問合せ、リードスルー/ライトスルー、ライトビハインドのローカル表示を確認できる一方で、いわば「こっそりのぞき見る」こともできます。

いくつかの応用例の中には、サービスの背後でマップをリスニングする必要がある場合があります。分散環境でのレプリケーション、パーティション、およびその他のデータ管理方式は、いずれも分散サービスです。このサービスにはさらに実際にデータを管理するための機能が必要です。それが「バッキング・マップ」と呼ばれるものです。

バッキング・マップは構成可能です。特定のキャッシュのすべてのデータを、ヒープのオブジェクト形式で保持する必要がある場合、無制限で失効期限のないLocalCache(統計が不要な場合はSafeHashMap)を使用します。メモリーに保持するアイテムの数が少ない場合は、LocalCacheを使用します。データを必要に応じてデータベースから読み取る場合は、ReadWriteBackingMapを使用します(アプリケーションのDAO実装を介した読取りおよび書込み方法を指定する)。ReadWriteBackingMapに、SafeHashMapLocalCacheなどのバッキング・マップを提供してデータを保存します。

バッキング・マップの中には監視可能なものがあります。これらのバッキング・マップから取得されたイベントは、一般的にはアプリケーションに直接関係がありません。かわりに、Coherenceではそれらを(Coherenceで)実行する必要があるアクションに変換してデータを同期的に保持し正しくバックアップを行い、またアプリケーション・リスナーでのリクエストに応じてそれをクラスタ全体に配信されるクラスタ化されたイベントに変換します。たとえば、パーティション・キャッシュにバッキング・マップとしてLocalCacheがあり、ローカル・キャッシュでエントリが失効した場合、そのイベントによってエントリのすべてのバックアップ・コピーが失効します。さらに、リスナーがパーティション・キャッシュに登録されている場合、イベントがイベント・フィルタに適合すると、そのイベントはそのリスナーが登録されているサーバーのリスナーに配信されます。

応用例の中には、データが保持されているサーバー上のイベントをアプリケーションで処理する必要があるものや、それを実際にデータを管理している構造(バッキング・マップ)で行う必要があるものがあります。そのような場合、バッキング・マップが監視可能なマップであれば、リスナーをバッキング・マップに構成したり、プログラムによってリスナーをバッキング・マップに追加することができます(バッキング・マップが監視可能でない場合、WrapperObservableMapでラップすることにより監視可能になる)。

これらのAPIの詳細は、Oracle Coherence C++ APIリファレンスを参照してください

14.12 応用: 同期イベント・リスナー

イベントの中には、アプリケーション・リスナーがイベントを生成するキャッシュ・サービスを妨害しないように、非同期に配信されるものがあります。まれなケースですが、非同期配信では進行している処理の結果に比べてイベントの順序があいまいになる場合があります。クラスタ・システムのローカル表示が単一スレッドであるかのようにキャッシュAPI操作およびイベントの順序を保証するには、MapListenerSynchronousListenerマーカー・インタフェースを実装する必要があります。

Coherence自体で同期リスナーを使用する例にニア・キャッシュがあります。これにより、ローカルでキャッシュされたデータを、イベントを使用して無効化できます(通称、Seppuku)。

このAPIの詳細は、Oracle Coherence C++ APIリファレンスを参照してください