非同期 Beanおよび CommonJ から EE Concurrency へのマイグレーション例
非同期 Bean と CommonJ Timer and Work Manager API を使用するアプリケーションは、Concurrency Utilities for Java™ EE を使用するようにマイグレーションできます。
Concurrency Utilities for Java EE は、アプリケーション・サーバー内で並行操作を実行するための標準化された手法を提供します。これは、非同期 Bean および CommonJ Timer and Work Manager のプログラミング・モデルを置き換えるものです。このページのコード例は、Concurrency Utilities for Java EE を使用するように既存のアプリケーションをマイグレーションする方法を示しています。

- コード例で使用されるリソース
- 基本的なタスクの実装
- タスクのサブミット
- タスクのグループの完了待機
- グループ内の単一タスクの完了待機
- タスクが失敗した場合の原因例外の取得
- 間隔の後に一回限りのタスクを実行するためのスケジュール
- 固定された頻度の反復タスクのスケジュールと、次回実行までの間隔の照会
- 可変間隔で実行される反復タスクのスケジュール
- タスクの実行の中断と再開
- タスクの実行の停止
- コンテキスト・プロキシーの構成
- 実行スレッドのトランザクション内で実行される複数インスタンスに対するコンテキスト・プロキシーの構成
- 呼び出し側スレッドに対する据え置き実行のためのコンテキスト・タスクの作成
- 据え置き実行のためのコンテキスト・タスクに対する追加オプション
- サブシステム・モニター
- イベント処理
- コンテキスト・プロキシーの呼び出し中に発生した障害に対するイベント処理
コード例で使用されるリソース
このページのコード例では、アプリケーションが以下のリソースを注入または検索したことを前提としています。
@Resource(lookup = "wm/default")
private com.ibm.websphere.asynchbeans.WorkManager abWorkManager;
@Resource(lookup = "wm/default")
private commonj.work.WorkManager cjWorkManager;
@Resource
private ContextService contextService;
@Resource(name = "java:app/env/jdbc/dsRef")
private DataSource dataSource;
@Resource
private ManagedScheduledExecutorService executor;
@Resource
private ManagedThreadFactory threadFactory;
@Resource(name = "java:comp/env/tm/default", lookup = "tm/default", shareable = false)
private TimerManager timerManager;
@Resource
private UserTransaction tran;
基本的なタスクの実装
ここでは、単純なタスクの実装例をいくつか示します。これらの例は、本書の以降の部分で他の例によって使用されます。非同期 Bean を使用するには、スケジュールに入れられて将来実行されるタスクのために、別個のインターフェース AlarmListener が必要です。CommonJ を使用するには、スケジュールに入れられて将来実行されるタスクのために、別個のインターフェース TimerListener が必要です。Concurrency Utilities for Java EE のタスクは Runnable または Callable のどちらかで、タスクがサブミットされて即時に実行されるか、スケジュールに入れられて将来実行されるかに関係なく、どちらのインターフェースを使用することもできます。 場合によっては、非同期 Bean または CommonJ の作業を Runnable として、変更を加えずに管理対象 executor にサブミットすることが可能です。作業の release メソッドは、管理対象 executor が実行中のスレッドを取り消し、中断する機能に置き換えられます。 作業の isDaemon メソッドは、LONGRUNNING_HINT 実行プロパティーに置き換えられます。
非同期 Bean と CommonJ の両方で次の素数を見つける Work タスクの例
public class PrimeFinderWork implements
com.ibm.websphere.asynchbeans.Work, commonj.work.Work {
private long num;
private volatile boolean released;
private long result;
public PrimeFinderWork(long startingValue) {
num = startingValue;
}
public boolean isDaemon() {
return false;
}
public void release() {
released = true;
}
public void run() {
while (!isPrime(num))
if (released || Thread.currentThread().isInterrupted())
throw new RuntimeException(new InterruptedException());
else
num++;
result = num++;
}
public long getPrimeNumber() {
if (result > 0)
return result;
else
throw new IllegalStateException();
}
}
次の素数を見つける非同期 Bean 用の AlarmListener タスクの例
public class PrimeFinderAlarmListener implements AlarmListener {
private volatile boolean aborted;
private int count;
private long num;
private long result;
public PrimeFinderAlarmListener(long startingValue) {
num = startingValue;
}
public void abort() {
aborted = true;
}
public void fired(Alarm alarm) {
while (!isPrime(num))
if (aborted || Thread.currentThread().isInterrupted())
throw new RuntimeException(new InterruptedException());
else
num++;
result = num++;
// optionally reschedule:
Object delays = alarm.getContext();
if (delays instanceof Integer)
alarm.reset((Integer) delays);
else if (delays instanceof int[] && count < ((int[]) delays).length)
alarm.reset(((int[]) delays)[count++]);
}
public long getPrimeNumber() {
if (result > 0)
return result;
else
throw new IllegalStateException();
}
次の素数を見つける非同期 Bean 用の TimerListener タスクの例
public class PrimeFinderTimerListener implements CancelTimerListener, TimerListener {
private volatile boolean aborted;
private int count;
private final long[] delays;
private long num;
private long result;
public PrimeFinderTimerListener(long startingValue, long... delays) {
num = startingValue;
this.delays = delays;
}
public void timerCancel(Timer timer) {
aborted = true;
}
public void timerExpired(Timer timer) {
while (!isPrime(num))
if (aborted || Thread.currentThread().isInterrupted())
throw new RuntimeException(new InterruptedException());
else
num++;
result = num++;
// optionally reschedule:
if (count < delays.length)
try {
TimerManager timerManager = (TimerManager) new InitialContext().lookup(
"java:comp/env/tm/default");
timerManager.schedule(this, delays[count++]);
} catch (NamingException x) {
throw new RuntimeException(x);
}
}
public long getPrimeNumber() {
if (result > 0)
return result;
else
throw new IllegalStateException();
}
}
次の素数を見つける Concurrency Utilities for Java EE 用の Runnable タスクの例:
public class PrimeFinderRunnable implements Runnable {
private long num;
private long result;
public PrimeFinderRunnable(long startingValue) {
num = startingValue;
}
public void run() {
while (!isPrime(num))
if (Thread.currentThread().isInterrupted())
throw new RuntimeException(new InterruptedException());
else
num++;
result = num++;
}
public long getPrimeNumber() {
if (result > 0)
return result;
else
throw new IllegalStateException();
}
}
次の素数を見つける Concurrency Utilities for Java EE 用の Callable タスクの例:
public class PrimeFinderTask implements Callable<Long> {
private long num;
public PrimeFinderTask(long startingValue) {
num = startingValue;
}
public Long call() throws InterruptedException {
while (!isPrime(num))
if (Thread.currentThread().isInterrupted())
throw new InterruptedException();
else
num++;
return num++;
}
}
基本的なデータベース挿入を実行する非同期 Bean 用の Work タスクの例:
public class DBInsertWorkAB implements Work, Serializable {
private static final long serialVersionUID = 2606824039439594442L;
private transient Thread executionThread;
private final String code;
private final String name;
private boolean released;
private volatile int result = -1;
public DBInsertWorkAB(String code, String name) {
this.code = code;
this.name = name;
}
public int getResult() {
return result;
}
public synchronized void release() {
released = true;
if (executionThread != null)
executionThread.interrupt();
}
public void run() {
synchronized (this) {
if (released)
throw new RuntimeException("Work was canceled");
executionThread = Thread.currentThread();
}
try {
DataSource ds = (DataSource) new InitialContext().lookup(
"java:app/env/jdbc/dsRef");
Connection con = ds.getConnection();
try {
PreparedStatement stmt = con.prepareStatement(
"INSERT INTO AIRPORTS VALUES(?,?)");
stmt.setString(1, code);
stmt.setString(2, name);
result = stmt.executeUpdate();
} finally {
con.close();
}
} catch (NamingException x) {
throw new RuntimeException(x);
} catch (SQLException x) {
throw new RuntimeException(x);
} finally {
synchronized (this) {
executionThread = null;
}
}
}
}
基本的なデータベース挿入を実行する非同期 Bean 用の AlarmListener タスクの例:
public class DBInsertAlarmListener implements AlarmListener {
private volatile int result = -1;
public int getResult() {
return result;
}
public void fired(Alarm alarm) {
String[] alarmContext = (String[]) alarm.getContext();
try {
DataSource ds = (DataSource) new InitialContext().lookup(
"java:app/env/jdbc/dsRef");
Connection con = ds.getConnection();
try {
PreparedStatement stmt = con.prepareStatement(
"INSERT INTO AIRPORTS VALUES(?,?)");
stmt.setString(1, alarmContext[0]);
stmt.setString(2, alarmContext[1]);
result = stmt.executeUpdate();
} finally {
con.close();
}
} catch (NamingException x) {
throw new RuntimeException(x);
} catch (SQLException x) {
throw new RuntimeException(x);
}
}
}
基本的なデータベース挿入を実行する CommonJ 用の Work タスクの例:
public class DBInsertWorkCJ implements Work, Serializable {
private static final long serialVersionUID = -8801347489043041978L;
private transient Thread executionThread;
private final String code;
private final String name;
private boolean isDaemon;
private boolean released;
private volatile int result = -1;
public DBInsertWorkCJ(String code, String name) {
this.code = code;
this.name = name;
}
public int getResult() {
return result;
}
public boolean isDaemon() {
return isDaemon;
}
public synchronized void release() {
released = true;
if (executionThread != null)
executionThread.interrupt();
}
public void run() {
synchronized (this) {
if (released)
throw new RuntimeException("Work was canceled");
executionThread = Thread.currentThread();
}
try {
DataSource ds = (DataSource) new InitialContext().lookup(
"java:app/env/jdbc/dsRef");
Connection con = ds.getConnection();
try {
PreparedStatement stmt = con.prepareStatement(
"INSERT INTO AIRPORTS VALUES(?,?)");
stmt.setString(1, code);
stmt.setString(2, name);
result = stmt.executeUpdate();
} finally {
con.close();
}
} catch (NamingException x) {
throw new RuntimeException(x);
} catch (SQLException x) {
throw new RuntimeException(x);
} finally {
synchronized (this) {
executionThread = null;
}
}
}
基本的なデータベース挿入を実行する CommonJ 用の TimerListener タスクの例:
public class DBInsertTimerListener implements TimerListener {
private volatile int result = -1;
private final String code;
private final String name;
public DBInsertTimerListener(String code, String name) {
this.code = code;
this.name = name;
}
public int getResult() {
return result;
}
public void timerExpired(Timer timer) {
try {
DataSource ds = (DataSource) new InitialContext().lookup(
"java:app/env/jdbc/dsRef");
Connection con = ds.getConnection();
try {
PreparedStatement stmt = con.prepareStatement(
"INSERT INTO AIRPORTS VALUES(?,?)");
stmt.setString(1, code);
stmt.setString(2, name);
result = stmt.executeUpdate();
} finally {
con.close();
}
} catch (NamingException x) {
throw new RuntimeException(x);
} catch (SQLException x) {
throw new RuntimeException(x);
}
}
}
基本的なデータベース挿入を実行する Concurrency Utilities for Java EE 用の Callable タスクの例:
public class DBInsertTask implements Callable<Integer>, Serializable {
private static final long serialVersionUID = 5556464104788801400L;
private final String code;
private final String name;
public DBInsertTask(String code, String name) {
this.code = code;
this.name = name;
}
public Integer call() throws NamingException, SQLException {
DataSource ds = (DataSource) new InitialContext().lookup(
"java:app/env/jdbc/dsRef");
Connection con = ds.getConnection();
try {
PreparedStatement stmt = con.prepareStatement(
"INSERT INTO AIRPORTS VALUES(?,?)");
stmt.setString(1, code);
stmt.setString(2, name);
return stmt.executeUpdate();
} finally {
con.close();
}
}
}
タスクのサブミット
3 つのプログラミング・モデルはすべて、基本的なタスクをサブミットしてプール・スレッド上で実行し、結果を取得するための手段を提供しています。
非同期 Bean の例:
WorkItem workItem = abWorkManager.startWork(
new DBInsertWorkAB("DLH", "Duluth International Airport"));
ArrayList<WorkItem> items = new ArrayList<WorkItem>(1);
items.add(workItem);
if (abWorkManager.join(items, WorkManager.JOIN_AND, TIMEOUT_MS)) {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
int numUpdates = work.getResult();
}
CommonJ の例:
WorkItem workItem = cjWorkManager.schedule(
new DBInsertWorkCJ("HIB", "Chisholm-Hibbing Airport"));
if (cjWorkManager.waitForAll(Collections.singletonList(workItem), TIMEOUT_MS)) {
DBInsertWorkCJ work = (DBInsertWorkCJ) workItem.getResult();
int numUpdates = work.getResult();
}
Concurrency Utilities for Java EE の例:
Future<Integer> future = executor.submit(
new DBInsertTask("INL", "Falls International Airport"));
int numUpdates = future.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
タスクをサブミットする際のその他のオプション
タスクをサブミットする際に、オプションでリスナーと開始タイムアウトを割り当て、長時間実行されることが予期されるかどうかを指定できます。開始タイムアウトは、非同期 Bean ではパラメーターとしてのみ使用できますが、 CommonJ および Concurrency Utilities for Java EE の場合は、WorkListener または ManagedTaskListener 内で開始タイムアウトを実装できます。
非同期 Bean の例:
long startTimeout = TIMEOUT_MS;
boolean isLongRunning = true;
WorkItem workItem = abWorkManager.startWork(
new DBInsertWorkAB("SGS", "South Saint Paul Municipal Airport"),
startTimeout,
new WorkListenerAB(),
isLongRunning);
ArrayList<WorkItem> items = new ArrayList<WorkItem>(1);
items.add(workItem);
if (abWorkManager.join(items, WorkManager.JOIN_AND, Integer.MAX_VALUE)) {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
int numUpdates = work.getResult();
}
CommonJ の例:
long startTimeout = TIMEOUT_MS;
boolean isLongRunning = true;
DBInsertWorkCJ work = new DBInsertWorkCJ("STP", "Saint Paul Downtown Airport");
work.setDaemon(isLongRunning);
WorkItem workItem = cjWorkManager.schedule(
work, new WorkListenerCJ(work, startTimeout));
Collection<WorkItem> items = Collections.singleton(workItem);
if (cjWorkManager.waitForAll(items, WorkManager.INDEFINITE)) {
work = (DBInsertWorkCJ) workItem.getResult();
int numUpdates = work.getResult();
}
Concurrency Utilities for Java EE の例:
long startTimeout = TIMEOUT_MS;
boolean isLongRunning = true;
Callable<Integer> contextualTask = ManagedExecutors.managedTask(
new DBInsertTask("LVN", "Airlake Airport"),
Collections.singletonMap(ManagedTask.LONGRUNNING_HINT,
Boolean.toString(isLongRunning)),
new TaskListener(startTimeout));
Future<Integer> future = executor.submit(contextualTask);
int numUpdates = future.get();
タスクのグループの完了待機
3 つのプログラミング・モデルはすべて、タスクのグループの完了を待機するための手段を提供しています。以下の例では、最大の待機時間を指定します。無期限に待機するか、Concurrency Utilities for Java EE を使用して future 変数の get を順次実行することが可能です。
ArrayList<WorkItem> items = new ArrayList<WorkItem>(3);
items.add(abWorkManager.startWork(
new DBInsertWorkAB("COQ", "Cloquet/Carlton County Airport")));
items.add(abWorkManager.startWork(
new DBInsertWorkAB("CQM", "Cook Municipal Airport")));
items.add(abWorkManager.startWork(
new DBInsertWorkAB("CKN", "Crookston Municipal Airport")));
boolean allCompleted = abWorkManager.join(items, WorkManager.JOIN_AND, TIMEOUT_MS);
int numUpdates = 0;
for (WorkItem workItem : items) {
if (workItem.getStatus() == WorkEvent.WORK_COMPLETED) {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
numUpdates += work.getResult();
} else
((Work) workItem.getEventTrigger(Work.class)).release();
}
CommonJ の例:
List<DBInsertWorkCJ> workList = Arrays.asList(
new DBInsertWorkCJ("DTL", "Detroit Lakes Airport"),
new DBInsertWorkCJ("TOB", "Dodge Center Airport"),
new DBInsertWorkCJ("DYT", "Sky Harbor Airport"));
List<WorkItem> items = new ArrayList<WorkItem>(workList.size());
for (DBInsertWorkCJ work : workList)
items.add(cjWorkManager.schedule(work));
boolean allCompleted = cjWorkManager.waitForAll(items, TIMEOUT_MS);
int numUpdates = 0;
for (int i = 0; i < items.size(); i++) {
WorkItem workItem = items.get(i);
if (workItem.getStatus() == WorkEvent.WORK_COMPLETED) {
DBInsertWorkCJ work = (DBInsertWorkCJ) workItem.getResult();
numUpdates += work.getResult();
} else
workList.get(i).release();
}
Concurrency Utilities for Java EE の例:
List<DBInsertTask> tasks = Arrays.asList(
new DBInsertTask("CFE", "Buffalo Municipal Airport"),
new DBInsertTask("CHU", "Caledonia-Houston County Airport"),
new DBInsertTask("CBG", "Cambridge Municipal Airport"));
int numUpdates = 0;
List<Future<Integer>> futures = executor.invokeAll(tasks, TIMEOUT_MS, TimeUnit.MILLISECONDS);
for (Future<Integer> future : futures)
numUpdates += future.get();
グループ内の単一タスクの完了待機
3 つのプログラミング・モデルはすべて、グループ内の単一タスクの完了を待機するための手段を提供しています。以下の例では、最大の待機時間を指定しますが、無期限に待機することも可能です。
非同期 Bean の例:
ArrayList<WorkItem> items = new ArrayList<WorkItem>(3);
items.add(abWorkManager.startWork(new PrimeFinderWork(20)));
items.add(abWorkManager.startWork(new PrimeFinderWork(50)));
items.add(abWorkManager.startWork(new PrimeFinderWork(80)));
boolean anyCompleted = abWorkManager.join(items, WorkManager.JOIN_OR, TIMEOUT_MS);
long prime = -1;
for (WorkItem workItem : items) {
if (workItem.getStatus() == WorkEvent.WORK_COMPLETED) {
PrimeFinderWork work = (PrimeFinderWork) workItem.getResult();
prime = work.getPrimeNumber();
} else
((Work) workItem.getEventTrigger(Work.class)).release();
}
CommonJ の例:
List<PrimeFinderWork> workList = Arrays.asList(
new PrimeFinderWork(20),
new PrimeFinderWork(50),
new PrimeFinderWork(80));
List<WorkItem> items = new ArrayList<WorkItem>(workList.size());
for (PrimeFinderWork work : workList)
items.add(cjWorkManager.schedule(work));
Collection<WorkItem> completedItems = cjWorkManager.waitForAny(items, TIMEOUT_MS);
long prime = -1;
for (int i = 0; i < items.size(); i++) {
WorkItem workItem = items.get(i);
if (completedItems.contains(workItem)) {
PrimeFinderWork work = (PrimeFinderWork) workItem.getResult();
prime = work.getPrimeNumber();
} else
workList.get(i).release();
}
Concurrency Utilities for Java EE の例:
List<PrimeFinderTask> tasks = Arrays.asList(
new PrimeFinderTask(20),
new PrimeFinderTask(50),
new PrimeFinderTask(80));
long prime = executor.invokeAny(tasks, TIMEOUT_MS, TimeUnit.MILLISECONDS);
タスクが失敗した場合の原因例外の取得
3 つのプログラミング・モデルはすべて、タスクの実行に失敗したときに原因例外を取得するための手段を提供しています。これは、リスナーを使用して行うか (例はこのページで後述)、WorkItem または Future からタスク結果を取得する際に行うことができます。 元の例外を理由として含む WorkException または ExecutionException が出されます。
非同期 Bean の例:
boolean isLongRunning = false;
WorkItem workItem = abWorkManager.startWork(
new DBInsertWorkAB("KADC", "Wadena Municipal Airport"),
isLongRunning);
Throwable exception = null;
ArrayList<WorkItem> items = new ArrayList<WorkItem>(1);
items.add(workItem);
if (abWorkManager.join(items, WorkManager.JOIN_AND, TIMEOUT_MS))
try {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
int numUpdates = work.getResult();
} catch (WorkException x) {
exception = x.getCause();
}
CommonJ の例:
boolean isLongRunning = false;
DBInsertWorkCJ work = new DBInsertWorkCJ("KBDH", "Willmar Municipal Airport");
work.setDaemon(isLongRunning);
WorkItem workItem = cjWorkManager.schedule(work);
Throwable exception = null;
if (cjWorkManager.waitForAll(Collections.singleton(workItem), TIMEOUT_MS))
try {
work = (DBInsertWorkCJ) workItem.getResult();
int numUpdates = work.getResult();
} catch (WorkException x) {
exception = x.getCause();
}
Concurrency Utilities for Java EE の例:
boolean isLongRunning = false;
Callable<Integer> task = ManagedExecutors.managedTask(
new DBInsertTask("KACQ", "Waseca Municipal Airport"),
Collections.singletonMap(ManagedTask.LONGRUNNING_HINT,
Boolean.toString(isLongRunning)),
null);
Future<Integer> future = executor.submit(task);
Throwable exception = null;
try {
int numUpdates = future.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
} catch (ExecutionException x) {
exception = x.getCause();
}
間隔の後に一回限りのタスクを実行するためのスケジュール
3 つのプログラミング・モデルはすべて、基本的なタスクをスケジュールに入れて将来いずれかの時点にプール・スレッド上で実行し、結果を取得するための手段を提供しています。
非同期 Bean の例:
AsynchScope asynchScope = abWorkManager.findOrCreateAsynchScope("MyScope");
AlarmManager alarmManager = asynchScope.getAlarmManager();
Alarm alarm = alarmManager.create(
new DBInsertAlarmListener(),
new String[] { "MSP", "Minneapolis-Saint Paul International Airport"},
(int) TimeUnit.SECONDS.toMillis(1));
DBInsertAlarmListener alarmListener = (DBInsertAlarmListener) alarm.getAlarmListener();
// Poll for result to appear
for (long start = System.nanoTime();
alarmListener.getResult() < 0 && System.nanoTime() - start < TIMEOUT_NS;
Thread.sleep(200)) ;
int numUpdates = alarmListener.getResult();
CommonJ の例:
Timer timer = timerManager.schedule(
new DBInsertTimerListener("STC", "Saint Cloud Regional Airport"),
TimeUnit.SECONDS.toMillis(1));
DBInsertTimerListener timerListener = (DBInsertTimerListener) timer.getTimerListener();
// Poll for result to appear
for (long start = System.nanoTime();
timerListener.getResult() < 0 && System.nanoTime() - start < TIMEOUT_NS;
Thread.sleep(200)) ;
int numUpdates = timerListener.getResult();
Concurrency Utilities for Java EE の例:
ScheduledFuture<Integer> future = executor.schedule(
new DBInsertTask("RST", "Rochester International Airport"),
1,
TimeUnit.SECONDS);
int numUpdates = future.get(TIMEOUT_NS, TimeUnit.NANOSECONDS);
固定された頻度の反復タスクのスケジュールと、次回実行までの間隔の照会
CommonJ および Concurrency Utilities for Java EE のプログラミング・モデルは、固定された頻度で (例えば、毎時ちょうどに) 実行するように反復タスクをスケジュールに入れるための手段を提供しています。リアルタイム・スケジューリングは保証されません。このタスクは、この時点より後のいずれかの時点で開始されますが、それより前に開始されることはありません。CommonJ および Concurrency Utilities for Java EE のプログラミング・モデルは、次回実行までの遅延を計算する便利メソッドも提供しています。
CommonJ の例:
Timer timer = timerManager.scheduleAtFixedRate(
new PrimeFinderTimerListener(120),
TimeUnit.MINUTES.toMillis(90),
TimeUnit.MINUTES.toMillis(30));
long nextExecTime = timer.getScheduledExecutionTime();
long delay = TimeUnit.MILLISECONDS.toSeconds(
nextExecTime - System.currentTimeMillis());
Concurrency Utilities for Java EE の例:
ScheduledFuture<?> future = executor.scheduleAtFixedRate(
new PrimeFinderRunnable(120), 90, 30, TimeUnit.MINUTES);
long delay = future.getDelay(TimeUnit.SECONDS);
固定された遅延の後に実行する反復タスクのスケジュール、およびタスクの取り消し
CommonJ および Concurrency Utilities for Java EE のプログラミング・モデルは、実行終了から次の実行開始まで固定された間隔で実行するように反復タスクをスケジュールに入れるための手段を提供しています。リアルタイム・スケジューリングは保証されません。このタスクは、この時点より後のいずれかの時点で開始されますが、それより前に開始されることはありません。非同期 Bean は Alarm のリセット・メソッドを提供しており、これを使用して同じ動作を実現できます。3 つのプログラミング・モデルはすべて、スケジュールに入れられたタスクの以後の実行開始を取り消すための手段を提供しています。
非同期 Bean の例:
AsynchScope asynchScope = abWorkManager.findOrCreateAsynchScope("MyScope");
AlarmManager alarmManager = asynchScope.getAlarmManager();
Alarm alarm = alarmManager.create(
new PrimeFinderAlarmListener(90), 50, 10);
// ... eventually cancel the alarm
alarm.cancel();
CommonJ の例:
Timer timer = timerManager.schedule(
new PrimeFinderTimerListener(90), 50, 50);
// ... eventually cancel the timer
timer.cancel();
Concurrency Utilities for Java EE の例:
ScheduledFuture<?> future = executor.scheduleWithFixedDelay(
new PrimeFinderRunnable(90), 50, 50, TimeUnit.MILLISECONDS);
// ... eventually cancel the task
future.cancel(false);
可変間隔で実行される反復タスクのスケジュール
3 つのプログラミング・モデルすべてで、それぞれの実行について、反復タスクの次回反復までの間隔を計算することが可能です。非同期 Bean は、アラームのリセット・メソッドを提供しています。 Concurrency Utilities for Java EE では、次の実行時間を計算するトリガーをプラグインできます。CommonJ はこれらのどちらも提供していませんが、CommonJ やその他のプログラミング・モデルでは、前回の実行が完了したときにタスクのスケジュールを変更することが可能です。以下の例では、タスクを 4 回限り実行し、それぞれの実行前に異なる遅延を設けるようにスケジュールを設定しています。次回実行のリセット、スケジュール変更、または計算を行うコードは、このセクションに記載されているトリガー内、および AlarmListener と TimerListener の実装 (『基本的なタスクの実装』セクションに記載) に含まれています。
非同期 Bean の例:
int initialDelay = 50;
int[] subsequentDelays = new int[] { 40, 80, 70 };
AsynchScope asynchScope = abWorkManager.findOrCreateAsynchScope("MyScope");
AlarmManager alarmManager = asynchScope.getAlarmManager();
Alarm alarm = alarmManager.create(
new PrimeFinderAlarmListener(60),
subsequentDelays,
initialDelay);
Thread.sleep(5000);
PrimeFinderAlarmListener alarmListener =
(PrimeFinderAlarmListener) alarm.getAlarmListener();
long prime = alarmListener.getPrimeNumber();
CommonJ の例:
long initialDelay = 50;
long [] subsequentDelays = new long[] { 40, 80, 70 };
Timer timer = timerManager.schedule(
new PrimeFinderTimerListener(60, subsequentDelays),
initialDelay);
Thread.sleep(5000);
PrimeFinderTimerListener timerListener = (PrimeFinderTimerListener) timer.getTimerListener();
long prime = timerListener.getPrimeNumber();
Concurrency Utilities for Java EE の例:
ScheduledFuture<Long> future = executor.schedule(
new PrimeFinderTask(60),
new DelayTrigger(50, 40, 80, 70));
Thread.sleep(5000);
long prime = future.get();
public class DelayTrigger implements Trigger {
private int count;
private long[] delays;
volatile boolean isSuspended;
public DelayTrigger(long... delays) {
this.delays = delays;
}
public Date getNextRunTime(LastExecution previousExecution, Date taskScheduledTime) {
if (delays.length > count)
return new Date(System.currentTimeMillis() + delays[count++]);
else
return null;
}
public boolean skipRun(LastExecution previousExecution, Date scheduledRunTime) {
return isSuspended;
}
}
タスクの実行の中断と再開
CommonJ TimerManager は、タスクの実行を中断および再開するためのインターフェースを提供しています。 Concurrency Utilities for Java EE は、プラグ可能トリガー・メカニズムの skipRun メソッドによって、この機能をよりきめ細かく提供します。 単一のトリガー・インスタンスを任意の数のタスクに提供できます (トリガーがこれをサポートするように実装されていれば)。以下の例では、単一タスクのスケジューリングに使用されるようにトリガーが作成されています。
CommonJ の例:
Timer timer = timerManager.schedule(
new PrimeFinderTimerListener(100),
new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(5)));
timerManager.suspend();
// ... resume at a later point
if (timerManager.isSuspending() || timerManager.isSuspended())
timerManager.resume();
Concurrency Utilities for Java EE の例:
DelayTrigger trigger = new DelayTrigger(
System.currentTimeMillis() + TimeUnit.DAYS.toMillis(5));
ScheduledFuture<Long> future = executor.schedule(
new PrimeFinderTask(100), trigger);
trigger.isSuspended = true;
// ... resume at a later point
if (trigger.isSuspended)
trigger.isSuspended = false;
タスクの実行の停止
非同期 Bean は、AsynchScope を破棄するための手段を提供しています。これにより、その有効範囲内で AlarmManagers によって作成されたすべてのアラームが取り消されます。CommonJ の TimerManager は、以降の実行を開始しないようにして、実行中のタスクがすべて停止するまで待機するためのインターフェースを提供します。これが可能な理由は、TimerManager の検索のたびに新規インスタンスが生成され、他のインスタンスとは独立して停止できるからです。Concurrency Utilities for Java EE では、同じ ManagedScheduledExecutorService が複数の検索にわたって共有され、shutdown、isTerminated、awaitTermination などのライフサイクル操作は許可されません (仕様により)。ただし、Concurrency Utilities for Java EE では、管理対象でない ScheduledExecutorService に対して ManagedThreadFactory を提供することによって、同様の動作を実現できます。
非同期 Bean の例:
alarmManager.create(
new PrimeFinderAlarmListener(100),
null,
(int) TimeUnit.HOURS.toMillis(1));
alarmManager.create(
new PrimeFinderAlarmListener(200),
null,
(int) TimeUnit.HOURS.toMillis(2));
// ... eventually destroy the asynch scope to cancel all alarms
asynchScope.destroy();
CommonJ の例:
TimerManager timerManager = (TimerManager) new InitialContext().lookup(
"java:comp/env/tm/default");
timerManager.schedule(
new PrimeFinderTimerListener(100),
new Date(System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1)));
timerManager.schedule(
new PrimeFinderTimerListener(200),
new Date(System.currentTimeMillis() + TimeUnit.HOURS.toMillis(2)));
// ... eventually stop the timer manager
timerManager.stop();
if (!timerManager.isStopped())
timerManager.waitForStop(TIMEOUT_MS);
Concurrency Utilities for Java EE の例:
ScheduledExecutorService executor =
Executors.newScheduledThreadPool(1, threadFactory);
executor.schedule(new PrimeFinderTask(100), 1, TimeUnit.HOURS);
executor.schedule(new PrimeFinderTask(200), 2, TimeUnit.HOURS);
// .. eventually shut down the executor
executor.shutdown();
if (!executor.isTerminated())
executor.awaitTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS);
コンテキスト・プロキシーの構成
非同期 Bean および Concurrency Utilities for Java EE のプログラミング・モデルでは、コンテキスト・プロキシーの構成が可能です。スレッド・コンテキストは、コンテキスト・プロキシーを作成するスレッドから取り込まれてその中に格納され、インターフェース・メソッドがプロキシー上で呼び出されると実行スレッドに自動的に適用され、後で実行スレッドから除去されます。非同期 Bean は、EventSource によってこれを提供します。Concurrency Utilities for Java EE は、ContextService によってこれを提供します。
非同期 Bean の例:
EventSource eventSource = abWorkManager.createEventSource();
eventSource.addListener(new DBWriterImpl());
DBWriter dbWriter = (DBWriter) eventSource.getEventTrigger(DBWriter.class);
// Can invoke interface methods from any thread...
int numUpdates = dbWriter.exec(
"INSERT INTO AIRPORTS VALUES(?,?)", "AIT", "Aitkin Municipal Airport");
Concurrency Utilities for Java EE の例:
DBWriter dbWriter = contextService.createContextualProxy(
new DBWriterImpl(), DBWriter.class);
// Can invoke interface methods from any thread...
int numUpdates = dbWriter.exec(
"INSERT INTO AIRPORTS VALUES(?,?)", "AXN", "Alexandria Municipal Airport");
実行スレッドのトランザクション内で実行される複数インスタンスに対するコンテキスト・プロキシーの構成
非同期 Bean および Concurrency Utilities for Java EE の両方とも、コンテキスト・プロキシーのインターフェース・メソッドが実行スレッドのトランザクション内で実行されるか、または現行トランザクションが中断され、メソッドの実行中は新規のトランザクション・コンテキストが適用されるかを指定できます。非同期 Bean のもう 1 つの機能は、複数のリスナー・インスタンスを単一のプロキシーによって起動できることです。一方、Concurrency Utilities for Java EE にはこの機能がなく、他の複数のリスナーに委任するラッパー・リスナーを作成することによって類似した動作を実現できます。次の例では、複数のリスナー・インスタンスを起動する単一のプロキシーを呼び出します。これらの起動は、すべて呼び出し側スレッドのトランザクションのもとで行われます。
非同期 Bean の例:
boolean runInSameTran = true;
EventSource eventSource = abWorkManager.createEventSource();
eventSource.addListener(new DBInsertTask("MKT", "Mankato Regional Airport"));
eventSource.addListener(new DBInsertTask("ULM", "New Ulm Municipal Airport"));
eventSource.addListener(new DBInsertTask("OWA", "Owatonna Degner Regional Airport"));
Callable<?> eventTrigger = (Callable<?>) eventSource.getEventTrigger(
Callable.class, runInSameTran);
// Can invoke interface methods from any thread...
tran.begin();
try {
eventTrigger.call();
} finally {
tran.commit();
}
Concurrency Utilities for Java EE の例:
Callable<?> eventTrigger = contextService.createContextualProxy(
new Callable<Void>() {
@Override
public Void call() throws Exception {
new DBInsertTask("FFM", "Fergus Falls Municipal Airport").call();
new DBInsertTask("ONA", "Winona Municipal Airport").call();
new DBInsertTask("OTG", "Worthington Municipal Airport").call();
return null;
}
},
Collections.singletonMap(ManagedTask.TRANSACTION,
ManagedTask.USE_TRANSACTION_OF_EXECUTION_THREAD),
Callable.class);
// Can invoke interface methods from any thread...
tran.begin();
try {
eventTrigger.call();
} finally {
tran.commit();
}
呼び出し側スレッドに対する据え置き実行のためのコンテキスト・タスクの作成
非同期 Bean を使用して、WorkWithExecutionContext を作成できます。これは、基本的にはタスクのシリアライズ可能なコンテキスト・プロキシーで、後で WorkManager にサブミットして作成元スレッドのスレッド・コンテキストのもとで実行できます。 呼び出し側スレッド (WorkManager の doWork メソッド) 上で実行することを意図していれば、コンテキスト・プロキシーは Concurrency Utilities for Java EE でも類似した動作を実現できます。
非同期 Bean の例:
WorkWithExecutionContext contextualWork = abWorkManager.create(
new DBInsertWorkAB("BJI", "Bemidji Regional Airport"));
// Can run the contextual work on any thread...
abWorkManager.doWork(contextualWork);
DBInsertWorkAB work = (DBInsertWorkAB) contextualWork.getWork();
int numUpdates = work.getResult();
Concurrency Utilities for Java EE の例:
Callable<Integer> contextualTask = contextService.createContextualProxy(
new DBInsertTask("BRD", "Brainerd Lakes Regional Airport"),
Callable.class);
// Can run the contextual proxy on any thread...
int numUpdates = contextualTask.call();
プール・スレッドに対する据え置き実行のためのコンテキスト・タスクの作成
非同期 Bean を使用して、WorkWithExecutionContext を作成できます。これは、基本的にはタスクのシリアライズ可能なコンテキスト・プロキシーで、後で WorkManager にサブミットして作成元スレッドのスレッド・コンテキストのもとで実行できます。 プール・スレッド (WorkManager の startWork メソッド) 上で実行することを意図していれば、管理対象 executor にタスクのコンテキスト・プロキシーをサブミットすることにより、Concurrency Utilities for Java EE でも類似した動作を実現できますが、スレッド・コンテキストの取り込みと伝搬が重複して行われるため、効率は低くなります。
非同期 Bean の例:
WorkWithExecutionContext contextualWork = abWorkManager.create(
new DBInsertWorkAB("ELO", "Ely Municipal Airport"));
WorkItem workItem = abWorkManager.startWork(contextualWork);
ArrayList<WorkItem> items = new ArrayList<WorkItem>(1);
items.add(workItem);
if (abWorkManager.join(items, WorkManager.JOIN_AND, TIMEOUT_MS)) {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
int numUpdates = work.getResult();
}
Concurrency Utilities for Java EE の例:
Callable<Integer> contextualTask = contextService.createContextualProxy(
new DBInsertTask("EVM", "Eveleth-Virginia Municipal Airport"),
Callable.class);
Future<Integer> future = executor.submit(contextualTask);
int numUpdates = future.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
据え置き実行のためのコンテキスト・タスクに対する追加オプション
据え置き実行のためにタスクをサブミットする際に、オプションでリスナーと開始タイムアウトを割り当て、長時間実行されることが予期されるかどうかを指定できます。開始タイムアウトは、非同期 Bean ではパラメーターとしてのみ使用できますが、 CommonJ および Concurrency Utilities for Java EE の場合は、WorkListener または ManagedTaskListener 内で開始タイムアウトを実装できます。
非同期 Bean の例:
long startTimeout = TIMEOUT_MS;
boolean isLongRunning = true;
WorkWithExecutionContext contextualWork = abWorkManager.create(
new DBInsertWorkAB("FRM", "Fairmont Municipal Airport"));
WorkItem workItem = abWorkManager.startWork(
contextualWork, startTimeout, new WorkListenerAB(), isLongRunning);
ArrayList<WorkItem> items = new ArrayList<WorkItem>(1);
items.add(workItem);
if (abWorkManager.join(items, WorkManager.JOIN_AND, Integer.MAX_VALUE)) {
DBInsertWorkAB work = (DBInsertWorkAB) workItem.getResult();
int numUpdates = work.getResult();
}
Concurrency Utilities for Java EE の例:
long startTimeout = TIMEOUT_MS;
boolean isLongRunning = true;
Callable<Integer> contextualTask = contextService.createContextualProxy(
new DBInsertTask("FBL", "Faribault Municipal Airport"),
Callable.class);
contextualTask = ManagedExecutors.managedTask(
contextualTask,
Collections.singletonMap(ManagedTask.LONGRUNNING_HINT,
Boolean.toString(isLongRunning)),
new TaskListener(startTimeout));
Future<Integer> future = executor.submit(contextualTask);
int numUpdates = future.get();
サブシステム・モニター
非同期 Bean は、アプリケーションやその他の成果物の間で調整を行い、可用性をモニターするためのメカニズムとして、SubsystemMonitor と SubsystemMonitorManager を提供しています。Concurrency Utilities for Java EE は、同等な機能を提供しません。この機能の代わりが必要な場合は、SubsystemMonitorManager の同等機能として動作する、他のすべてのアプリケーションに認識されるアプリケーションを実装することによって実現できます。
イベント処理
非同期 Bean は、AlarmManager、AsynchScope、EventSource、SubsystemMonitor、WorkManager、および Work 上で発生するさまざまなタイプのイベントに対するリスナーを登録する機能を備えています。Concurrency Utilities for Java EE では、これらのイベントのほとんどに直接相当するものがありません。イベントと通知に対応する独自のメカニズムをアプリケーションの側で実装する必要があります。いくつかのケースでは、Concurrency Utilities for Java EE は同様な機能を提供しています。場合によっては、ManagedTaskListener を使用できることがあります。これは、AlarmManagerEvents および WorkEvents の代わりに、より高い細分度で (タスクのサブミット時に) 登録されます。
コンテキスト・プロキシーの呼び出し中に発生した障害に対するイベント処理
非同期 Bean では、コンテキスト・プロキシーを使用して操作を呼び出し、その操作から宣言済み例外が発生した場合に、その例外が呼び出し側に報告されません。代わりに、listenerExceptionThrown イベントに対する例外が EventSourceEvents リスナーに報告されます。Concurrency Utilities for Java EE では、呼び出し側はこの例外を catch して処理できます。
非同期 Bean の例:
EventSource eventSource = abWorkManager.createEventSource();
eventSource.addListener(new DBWriterImpl());
eventSource.addListener(new EventSourceEvents() {
public void listenerCountChanged(
EventSource es, int oldCount, int newCount) {}
public void listenerExceptionThrown(
EventSource es, Object listener,
String methodName, Throwable exception) {
listenerException.set(exception);
}
public void unexpectedException(
EventSource es, Object runnable, Throwable exception) {}
});
DBWriter dbWriter = (DBWriter) eventSource.getEventTrigger(DBWriter.class);
// Can invoke interface methods from any thread...
try {
dbWriter.exec(
"INSERT INTO AIRPORTS VALUES(?,?)", "KAUM", "Austin Municipal Airport");
} catch (Exception x) {
// expecting this to fail
}
Throwable exception = listenerException.get();
Concurrency Utilities for Java EE の例:
DBWriter dbWriter = contextService.createContextualProxy(
new DBWriterImpl(), DBWriter.class);
// Can invoke interface methods from any thread...
SQLException exception = null;
try {
dbWriter.exec(
"INSERT INTO AIRPORTS VALUES(?,?)", "KSBU", "Blue Earth Municipal Airport");
} catch (SQLException x) {
exception = x;
}