Work managers

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");

InitialContext ctx = new InitialContext();
java.util.concurrent.ExecutorService execSvc = 
 (java.util.concurrent.ExecutorService
       ctx.lookup("java:comp/env/concurrent/execSvc");

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.....");
	  }

// A simple task that can be used as either Callable or Runnable
 public class MyWork implements Callable<Integer>, Runnable {
   final AtomicInteger counter;
   
   public MyWork(AtomicInteger counter) {
     this.counter = counter;
   }
   
   @Override // the Callable implementation
   public Integer call() {
     int i = counter.incrementAndGet();
     System.out.println("callable counter = " + i);
     return i;
   }
   
   @Override // the Runnable implementation
   public void run() {
     int i = counter.incrementAndGet();
     System.out.println("runnable counter = " + i);
   }
 }

	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());
	      }
	  }
	}

AtomicInteger counter = new AtomicInteger();
   
   Callable<Integer> callableTask = new MyWork(counter);
   Runnable runnableTask = new MyWork(counter);
   
   // Submit single tasks for execution
   Future<Integer> future1 = execSvc.submit(callableTask);
   Future<?> future2 = execSvc.submit(runnableTask);
   Future<Integer> future3 = execSvc.submit(runnableTask, 100);
   
   // in a perfect world the results should be:
   // future1.get() -> 1
   // future2.get() -> null
   // future3.get() -> 100
   
   List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>(3);
   tasks.add(new MyWork(counter));
   tasks.add(new MyWork(counter));
   tasks.add(new MyWork(counter));
   
   // submit multiple tasks and block until all items are done
   List<Future<Integer>> futures = execSvc.invokeAll(tasks);
   futures = execSvc.invokeAll(tasks, 1000, TimeUnit.MILLISECONDS); // with timeout
   
   // submit multiple tasks and  block until 1 task completes successfully
   Integer result = execSvc.invokeAny(tasks);
   result = execSvc.invokeAny(tasks, 1000, TimeUnit.MILLISECONDS); // with timeout

	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");

	// 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);