作業マネージャー

作業マネージャーは、Java™ Platform, Enterprise Edition (Java EE) アプリケーションのスレッド化を提供します。

管理者は、管理コンソールを使用して、任意の数の作業マネージャーを構成できます。 管理者は、作業マネージャーにサブミットされるタスクの Java EE コンテキスト継承ポリシーを含めて、作業マネージャーのプロパティーを指定します。管理者は、各作業マネージャーを Java Naming and Directory Interface (JNDI) 内の固有の場所にバインドします。 作業マネージャー・オブジェクトは、以下のいずれか 1 つのインターフェースで使用できます。
  • Managed Executor
    • javax.enterprise.concurrent.ManagedExecutorService
    • javax.enterprise.concurrent.ManagedScheduledExecutorService
    • java.util.concurrent.ExecutorService
    • java.util.concurrent.ScheduledExecutorService
  • スレッド・ファクトリー
    • javax.enterprise.concurrent.ManagedThreadFactory
    • java.util.concurrent.ThreadFactory
  • スレッド・コンテキスト・サービス
    • javax.enterprise.concurrent.ContextService
  • 非同期 Bean
    • com.ibm.websphere.asynchbeans.WorkManager
  • CommonJ 作業マネージャー
    • commonj.work.WorkManager
選択されたタイプのインターフェースは、リソース環境参照に指定された値に基づいて JNDI 検索時間中に解決されます。

作業マネージャーは、Java EE アプリケーション用のプログラミング・モデルを提供します。詳しくは、『プログラミング・モデル』セクションを参照してください。

トラブルの回避 (Avoid trouble) トラブルの回避 (Avoid trouble): javax.resource.spi.work.WorkManager クラス は、Java EE コネクター・アーキテクチャー (JCA) リソース・アダプターによって 使用される Java インターフェースです。これは、Java EE アプリケーションによって使用される WorkManager の実際の実装ではありません。gotcha

Concurrency Utilities for Java EE または非同期 Bean を使用する Web コンポーネントまたは Enterprise JavaBeans (EJB) コンポーネントを作成する場合、 開発者は、管理対象 executor、スレッド・ファクトリー、コンテキスト・サービス、または作業マネージャーへのアクセスを必要とする各コンポーネントにリソース環境参照を組み込む必要があります。 リソース参照について詳しくは、『参照』トピックを参照してください。コンポーネントは、データ・ソース、エンタープライズ Bean、または接続ファクトリーをルックアップする場合と同様、 コンポーネント内での論理名 (java: comp 名前空間) を使用する、管理対象 executor、スレッド・ファクトリー、コンテキスト・サービス、または作業マネージャーをルックアップします。

デプロイヤーは、アプリケーションがデプロイされるときに、物理作業マネージャーを論理リソース環境参照 (管理対象 executor、スレッド・ファクトリー、コンテキスト・サービス、または作業マネージャー) にバインドします。

例えば、開発者が作業を銅レベル、銀レベル、および金レベルの間で区分するために 3 つのスレッド・プールを必要とする場合、開発者は、クライアント・アプリケーション・プロファイル内の属性に基づく論理プールを選択するためのコンポーネントを作成します。 デプロイヤーは、この 3 つのスレッド・プールの要求をマップする方法を柔軟に決定できます。 デプロイヤーは、小規模のシステム上で単一のスレッド・プールを使用することを決定する場合があります。 この場合、デプロイヤーは、3 つのリソース参照をすべて同じ作業マネージャー・インスタンス (つまり、同じ JNDI 名) にバインドします。 より大きなシステムを使用すると、3 つのスレッド・プールがサポートされる場合があります。この場合、デプロイヤーは、各リソース参照を別々の作業マネージャーにバインドします。作業マネージャーは、同じサーバー上にインストールされた複数の Java EE アプリケーション間で共有できます。

アプリケーション開発者は、論理リソース環境参照を、必要に応じていくつでも使用できます。デプロイヤーは、アプリケーション内で定義された論理的な管理対象 executor、スレッド・ファクトリー、コンテキスト・サービス、または作業マネージャーに、物理的な作業マネージャーを 1 つマップするか、または複数マップするかを選択します。

複数の非同期有効範囲オブジェクトを共有する必要のある Java EE コンポーネントは、すべて同じ作業マネージャーを使用する必要があります。 これらの有効範囲オブジェクトは、単一の作業マネージャーとアフィニティーがあります。非同期有効範囲を使用するアプリケーションは、有効範囲オブジェクトを使用するすべてのコンポーネントが同じ作業マネージャーを使用することも検証する必要があります。

複数の作業マネージャーが定義されているときは、Java 仮想マシン (JVM) 内のアプリケーションがその作業マネージャーを検索する場合にのみ、 基礎になるスレッド・プールがその JVM 内に作成されます。 例えば、10 個のスレッド・プール (作業マネージャー) が定義されていても、アプリケーションがこれらのプールをルックアップするまでは 1 つも作成されません。

重要: 作業マネージャーは、リモート JVM への作業のサブミットをサポートしていません。

CommonJ 作業マネージャー

CommonJ 作業マネージャーには、非同期 Bean 作業マネージャー・メソッドのサブセットが含まれています。CommonJ 作業マネージャーは Java EE 1.4 環境で機能しますが、この仕様は Java EE 仕様には含まれていないため、このインターフェースは、JNDI ネーミング検索ごとに新規インスタンスを戻しません。

リモートで実行される作業用の CommonJ 作業仕様のオプション・フィーチャーは、 サポートされていません。 作業単位が java.io.Serializable インターフェースを実装する場合であっても、 その作業単位はリモートでは実行されません。

管理対象 executor のルックアップ方法

アプリケーションは次のようにして管理対象 executor をルックアップできます。コンポーネントには、コンポーネントがデプロイされた時に物理作業マネージャーにバインドされた、concurrent/myExecutor という名前のリソース環境参照が含まれています。
InitialContext ic = new InitialContext();
ManagedExecutorService executor = (ManagedExecutorService) ic.lookup("java:comp/env/concurrent/myExecutor");

Java EE コンテキストの継承

管理対象 executor および作業マネージャーにサブミットされるタスクは、以下の Java EE コンテキストを、サブミットするスレッドから継承できます。コンテキスト・プロキシーは、これらのタイプのコンテキストを、 コンテキスト・プロキシーを作成するためにコンテキスト・サービスを起動するスレッドから継承できます。管理対象スレッド・ファクトリーのスレッドは、 これらのタイプのコンテキストを、管理対象スレッド・ファクトリーをルックアップまたは注入するスレッドから継承できます。
国際化対応コンテキスト
このオプションが選択され、国際化対応サービスが使用可能になっている場合、スケジューリング・スレッドに存在する国際化対応コンテキストは、ターゲット・スレッドで使用可能になります。
作業域
このオプションが選択されると、スケジューリング・スレッドに存在するすべての作業域区画の作業域コンテキストが、ターゲット・スレッドで使用可能になります。
アプリケーション・プロファイル (推奨されません)
アプリケーション・プロファイル・コンテキストはサポートされておらず、ほとんどのアプリケーションで使用できません。Java EE 1.3 アプリケーションでは、このオプションが選択されると、 アプリケーション・プロファイル・サービスが使用可能になり、 アプリケーション・プロファイル・サービス・プロパティー 5.x 互換モードが選択されます。 スケジューリング・スレッドに関連付けられているアプリケーション・プロファイル・タスクが、 Java EE 1.3 アプリケーションのターゲット・スレッドで使用可能になります。 Java EE 1.4 以上のアプリケーションの場合、アプリケーション・プロファイル・タスクは、スレッドではなく、関連付けられた作業単位のプロパティーです。このオプションは、Java EE 1.4 以上のアプリケーションの動作には効果がありません。Java EE 1.4 アプリケーションで実行されるスケジュール済み作業は、スケジューリング・スレッドのプロファイル・タスクを受け取りません。
セキュリティー
タスクは、匿名で、またはそのタスクを作成およびサブミットしたスレッドで認証されたクライアントとして実行できます。タスクは、呼び出し元が実行できることしか実行できないため、この振る舞いは有用です。また、このアクションは、例えばこの種の振る舞いを阻止する RUN_AS メカニズムよりもずっと役立ちます。セキュリティー・オプションが選択されると、スケジューリング・スレッドに存在する JAAS 対象が、ターゲット・スレッドで使用可能になります。選択されていない場合は、スレッドは匿名で実行されます。
コンポーネント・メタデータ
コンポーネント・メタデータが関係あるのは、タスクが単純な Java オブジェクトの場合のみです。タスクが、エンタープライズ Bean などの Java EE コンポーネントの場合、コンポーネント・メタデータはアクティブです。

継承できるコンテキストは、タスクを作成しサブミットするアプリケーションによって使用される作業マネージャーによって決まります。管理者は、管理コンソールを使用して、作業マネージャーを使用可能にするサービスを選択し、作業マネージャーのスティッキー・コンテキスト・ポリシーを定義します。

プログラミング・モデル

作業マネージャーは以下のプログラミング・モデルをサポートしています。
  • Concurrency Utilities for Java EE。Java EE 仕様は、よく知られている Java SE java.util.concurrent API から継承する Managed Executor、Managed Scheduled Executor、および Managed Thread Factory を含むこのプログラミング・モデルを標準化しています。これは、 java.util.concurrent API には対応するものがない Context Service も含みます。
  • 非同期 Bean。現行の非同期 Bean 作業マネージャー、イベント・ソース、非同期有効範囲、サブシステム・モニター、および Java EE Context インターフェースは、非同期 Bean プログラミング・モデルの一部です。
  • CommonJ 仕様。CommonJ プログラミング・モデルでは、 WorkManager および TimerManager を使用して、Java EE 環境でスレッドおよびタイマーを非同期的に管理します。

管理対象 executor、スレッド・ファクトリー、コンテキスト・サービス、および作業マネージャー API について詳しくは、Javadoc を参照してください。

Concurrency の例

表 1. 管理対象 executor または作業マネージャーのルックアップ
管理対象 Executor 非同期 Bean CommonJ
InitialContext ctx = new InitialContext();
ManagedExecutorService executor =
(ManagedExecutorService)
   ctx.lookup("java:comp/env/wm/myWorkMgr");
InitialContext ctx = new InitialContext();
com.ibm.websphere.asynchbeans.WorkManager wm  =
(com.ibm.websphere.asynchbeans.WorkManager)
   ctx.lookup(“java:comp/env/wm/MyWorkMgr”);
InitialContext ctx = new InitialContext();
commonj.work.WorkManager wm = (commonj.work.WorkManager)
   ctx.lookup(“java:comp/env/wm/MyWorkMgr”);
表 2. タスクの作成
管理対象 Executor 非同期 Bean CommonJ
 public class MyWork implements Callable<Integer> {
     public Integer call() {
       	     System.out.println(“Running.....");
       return 1;
     }
   }
public class MyWork implements 
com.ibm.websphere.asynchbeans.Work {
   public void release() {
            ......
   }
   	   public void run() {
    	     System.out.println(“Running.....");
}
public class MyWork implements 
commonj.work.Work{
   	   public boolean isDaemon() {
       return false;
   }
   public void release () {
        .....
   }
    	   public void run() {
     	     System.out.println(“Running.....");
  }
表 3. タスクのサブミット
管理対象 Executor 非同期 Bean CommonJ
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();

	// case 1: block until all items are done
Collection<MyWork> tasks =
    Arrays.asList(work1, work2);
List<Future<Integer>> futures =
    executor.invokeAll(tasks);
for (Future<Integer> future : futures)
    System.out.println("work data=" + future.get());

//case 2: wait up to 1000 milliseconds for any of the items to complete.
Integer result = executor.invokeAny(
    tasks, 1, TimeUnit.SECONDS);
System.out.println("work data=" + result);
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();

	WorkItem item1;
	WorkItem item2;
Item1=wm.startWork(work1);
	Item2=wm.startWork(work2);
	
	// case 1: block until all items are done
	ArrayList col1 = new ArrayList();
Col1.add(item1);
	Col1.add(item2);
wm.join(col1, WorkManager.JOIN_AND, WorkManager.INDEFINITE);
	// when the works are done
	System.out.println(“work1 data="+work1.getData());
	System.out.println(“work2 data="+work2.getData());
	
	// you should complete case 1 before case 2
//case 2: wait up to 1000 milliseconds for any of the items to complete.
	Boolean ret = wm.join(col1,                           WorkManager.JOIN_OR, 1000);
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();
	
	WorkItem item1;
	WorkItem item2;
Item1=wm.schedule(work1 );
	Item2=wm.schedule(work2);
	
	// case 1: block until all items are done
	Collection col1 = new ArrayList();
col1.add(item1);
	col1.add(item2);
	wm.waitForAll(col1, WorkManager.INDEFINITE);
	// when the works are done
	System.out.println(“work1 data="+work1.getData());
	System.out.println(“work2 data="+work2.getData());
	
	// you should complete case 1 before case 2
//case 2: wait up to 1000 milliseconds for any of the items to complete.
Collection finished = wm.waitForAny(col1,1000);
	// check the workItems status
if (finished != null) {
	  Iterator I = finished.iterator();
	  	  if (i.hasNext()) {
	     WorkItem wi = (WorkItem) i.next();
	      	      if (wi.equals(item1)) {
	        System.out.println(“work1 = “+ work1.getData());
	      	      } else if (wi.equals(item2)) {
	        	        System.out.println(“work1 = “+ work1.getData());
	      }
	  }
}
表 4. Managed Scheduled Executor、アラーム・マネージャー、またはタイマー・マネージャーの作成
管理対象の予約済み executor 非同期 Bean CommonJ
InitialContext ctx = new InitialContext();
ManagedScheduledExecutorService executor =
  (ManagedScheduledExecutorService)
    ctx.lookup("java:comp/env/wm/MyWorkMgr");
InitialContext ctx = new InitialContext();
com.ibm.websphere.asynchbeans.WorkManager wm  =
    (com.ibm.websphere.asynchbeans.WorkManager)
      	       ctx.lookup(“java:comp/env/wm/MyWorkMgr");	
	AsynchScope ascope;
Try {
  	  Ascope = wm.createAsynchScope(“ABScope");
	} Catch (DuplicateKeyException ex)
{
   	   Ascope = wm.findAsynchScope(“ABScope");
   ex.printStackTrace();
}

	// get an AlarmManager 
	AlarmManager  aMgr= ascope.getAlarmManager();
InitialContext ctx = new InitialContext();
	Commonj.timers.TimerManager tm = (commonj.timers.TimerManager) ctx.lookup(“java:comp/env/tm/MyTimerManager”);
表 5. タスク、アラーム、またはタイマーのスケジュール
管理対象の予約済み executor 非同期 Bean CommonJ
// create task
Runnable task = new StockQuoteTask(
    “qqq”, “johndoe@example.com”);
ScheduledFuture<?> future =
     executor.schedule(task, 1, TimeUnit.MINUTES);

// Fixed-delay: schedule task to run
// 1 minute from now and repeat every
// hour thereafter.  
ScheduledFuture<?> future =
    executor.scheduleWithFixedDelay(
        task, 1, 60, TimeUnit.MINUTES);

// Fixed-rate: schedule timer to expire
// 1 minute from now and repeat every
// hour thereafter
ScheduledFuture<?> future =
    executor.scheduleAtFixedRate(
        task, 1, 60, TimeUnit.MINUTES);
// create alarm
	ABAlarmListener listener = new ABAlarmListener();
	Alarm am = aMgr.create(listener, “SomeContext”, 1000*60);
// create timer
	TimerListener listener = new StockQuoteTimerListener(“qqq", “johndoe@example.com");
	Timer timer = tm.schedule(listener, 1000*60);
	
	// Fixed-delay: schedule timer to expire in
	// 60 seconds from now and repeat every
// hour thereafter.  
	Timer timer = tm.schedule(listener, 1000*60, 1000*30);
	
	// Fixed-rate: schedule timer to expire in
	// 60 seconds from now and repeat every
// hour thereafter
	Timer timer = tm.scheduleAtFixedRate(listener, 1000*60, 1000*30);

トピックのタイプを示すアイコン 概念トピック



タイム・スタンプ・アイコン 最終更新: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=casb_workmgr
ファイル名:casb_workmgr.html