* An invocable agent that operates against the Entry objects within a

* Map.

*/

public interface EntryProcessor

extends Serializable

{

/**

* Process a Map Entry.

*

* @param entry  the Entry to process

*

* @return the result of the processing, if any

*/

public Object process(Entry entry);

/**

* Process a Set of InvocableMap Entry objects. This method is

* semantically equivalent to:

* <pre>

*   Map mapResults = new ListMap();

*   for (Iterator iter = setEntries.iterator(); iter.hasNext(); )

*       {

*       Entry entry = (Entry) iter.next();

*       mapResults.put(entry.getKey(), process(entry));

*       }

*   return mapResults;

* </pre>

*

* @param setEntries  a read-only Set of InvocableMap Entry objects to

*                    process

*

* @return a Map containing the results of the processing, up to one

*         entry for each InvocableMap Entry that was processed, keyed

*         by the keys of the Map that were processed, with a

*         corresponding value being the result of the processing for

*         each key

*/

public Map processAll(Set setEntries);

}

* An InvocableMap Entry contains additional information and exposes

* additional operations that the basic Map Entry does not. It allows

* non-existent entries to be represented, thus allowing their optional

* creation. It allows existent entries to be removed from the Map. It

* supports several optimizations that can ultimately be mapped

* through to indexes and other data structures of the underlying Map.

*/

public interface Entry

extends Map.Entry

{

// ----- Map Entry interface ------------------------------------

/**

* Return the key corresponding to this entry. The resultant key does

* not necessarily exist within the containing Map, which is to say

* that <tt>InvocableMap.this.containsKey(getKey)</tt> could return

* false. To test for the presence of this key within the Map, use

* {@link #isPresent}, and to create the entry for the key, use

* {@link #setValue}.

*

* @return the key corresponding to this entry; may be null if the

*         underlying Map supports null keys

*/

public Object getKey();

/**

* Return the value corresponding to this entry. If the entry does

* not exist, then the value is null. To differentiate between

* a null value and a non-existent entry, use {@link #isPresent}.

* <p/>

* <b>Note:</b> any modifications to the value retrieved using this

* method are not guaranteed to persist unless followed by a

* {@link #setValue} or {@link #update} call.

*

* @return the value corresponding to this entry; may be null if the

*         value is null or if the Entry does not exist in the Map

*/

public Object getValue();

/**

* Store the value corresponding to this entry. If the entry does

* not exist, then the entry is created by invoking this method,

* even with a null value (assuming the Map supports null values).

*

* @param oValue  the new value for this Entry

*

* @return the previous value of this Entry, or null if the Entry did

*         not exist

*/

public Object setValue(Object oValue);

// ----- InvocableMap Entry interface ---------------------------

/**

* Store the value corresponding to this entry. If the entry does

* not exist, then the entry is created by invoking this method,

* even with a null value (assuming the Map supports null values).

* <p/>

* Unlike the other form of {@link #setValue(Object) setValue}, this

* form does not return the previous value, and consequently may be

* significantly less expensive (in terms of cost of execution) for

* certain Map implementations.

*

* @param oValue      the new value for this Entry

* @param fSynthetic  pass true only if the insertion into or

*                    modification of the Map should be treated as a

*                    synthetic event

*/

public void setValue(Object oValue, boolean fSynthetic);

/**

* Extract a value out of the Entry‘s value. Calling this method is

* semantically equivalent to

* <tt>extractor.extract(entry.getValue())</tt>, but this method may

* be significantly less expensive because the resultant value may be

* obtained from a forward index, for example.

*

* @param extractor  a ValueExtractor to apply to the Entry‘s value

*

* @return the extracted value

*/

public Object extract(ValueExtractor extractor);

/**

* Update the Entry‘s value. Calling this method is semantically

* equivalent to:

* <pre>

*   Object oTarget = entry.getValue();

*   updater.update(oTarget, oValue);

*   entry.setValue(oTarget, false);

* </pre>

* The benefit of using this method is that it may allow the Entry

* implementation to significantly optimize the operation, such as

* for purposes of delta updates and backup maintenance.

*

* @param updater  a ValueUpdater used to modify the Entry‘s value

*/

public void update(ValueUpdater updater, Object oValue);

/**

* Determine if this Entry exists in the Map. If the Entry is not

* present, it can be created by calling {@link #setValue} or

* {@link #setValue}. If the Entry is present, it can be destroyed by

* calling {@link #remove}.

*

* @return true iff this Entry is existent in the containing Map

*/

public boolean isPresent();

/**

* Remove this Entry from the Map if it is present in the Map.

* <p/>

* This method supports both the operation corresponding to

* {@link Map#remove} and synthetic operations such as

* eviction. If the containing Map does not differentiate between

* the two, then this method must be identical to

* <tt>InvocableMap.this.remove(getKey())</tt>.

*

* @param fSynthetic  pass true only if the removal from the Map

*                    should be treated as a synthetic event

*/

public void remove(boolean fSynthetic);

}

* Perform an aggregating operation against the entries specified by the

* passed keys.

*

* @param collKeys  the Collection of keys that specify the entries within

*                  this Map to aggregate across

* @param agent     the EntryAggregator that is used to aggregate across

*                  the specified entries of this Map

*

* @return the result of the aggregation

*/

public Object aggregate(Collection collKeys, EntryAggregator agent);

/**

* Perform an aggregating operation against the set of entries that are

* selected by the given Filter.

* <p/>

* <b>Note:</b> calling this method on partitioned caches requires a

* Coherence Enterprise Edition (or higher) license.

*

* @param filter  the Filter that is used to select entries within this

*                Map to aggregate across

* @param agent   the EntryAggregator that is used to aggregate across

*                the selected entries of this Map

*

* @return the result of the aggregation

*/

public Object aggregate(Filter filter, EntryAggregator agent);

* An EntryAggregator represents processing that can be directed to occur

* against some subset of the entries in an InvocableMap, resulting in a

* aggregated result. Common examples of aggregation include functions

* such as min(), max() and avg(). However, the concept of aggregation

* applies to any process that must evaluate a group of entries to

* come up with a single answer.

*/

public interface EntryAggregator

extends Serializable

{

/**

* Process a set of InvocableMap Entry objects to produce an

* aggregated result.

*

* @param setEntries  a Set of read-only InvocableMap Entry objects to

*                    aggregate

*

* @return the aggregated result from processing the entries

*/

public Object aggregate(Set setEntries);

}

* A ParallelAwareAggregator is an advanced extension to EntryAggregator

* that is explicitly capable of being run in parallel, for example in a

* distributed environment.

*/

public interface ParallelAwareAggregator

extends EntryAggregator

{

/**

* Get an aggregator that can take the place of this aggregator in

* situations in which the InvocableMap can aggregate in parallel.

*

* @return the aggregator that is run in parallel

*/

public EntryAggregator getParallelAggregator();

/**

* Aggregate the results of the parallel aggregations.

*

* @return the aggregation of the parallel aggregation results

*/

public Object aggregateResults(Collection collResults);

}

* Agent that issues a garbage collection.

*/

public class GCAgent

extends AbstractInvocable

{

public void run()

{

System.gc();

}

}

* 代理确定网格节点有多少空闲内存。

*/

public class FreeMemAgent

extends AbstractInvocable

{

public void run()

{

Runtime runtime = Runtime.getRuntime();

int cbFree  = runtime.freeMemory();

int cbTotal = runtime.totalMemory();

setResult(new int[] {cbFree, cbTotal});

}

}

while (iter.hasNext())

{

Map.Entry entry  = (Map.Entry) iter.next();

Member    member = (Member) entry.getKey();

int[]     anInfo = (int[]) entry.getValue();

if (anInfo != null) // nullif member died

System.out.println("Member " + member + " has "

+ anInfo[0] + " bytes free out of "

+ anInfo[1] + " bytes total");

}

* Agent that carries some state with it.

*/

public class StatefulAgent

extends AbstractInvocable

{

public StatefulAgent(String sKey)

{

m_sKey = sKey;

}

public void run()

{

// the agent has the key that it was constructed with

String sKey = m_sKey;

// ...

}

private String m_sKey;

}

Collection collBigItems = new ArrayList();

Collection collAllItems = new ArrayList();

for (int i = 0, c = aWork.length; i < c; ++i)

{

WorkItem item = manager.schedule(aWork[i]);

if (i < 3)

{

// the first three work items are the important ones

collBigItems.add(item);

}

collAllItems.add(item);

}

Collection collDone = manager.waitForAll(collAllItems, 5000L);

if (!collDone.containsAll(collBigItems))

{

// wait the remainder of 30 seconds for the important work to finish

manager.waitForAll(collBigItems, 25000L);

}