Java Work类代码示例

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Override
public long startWork(Work work, long startTimeout, ExecutionContext executionContext, WorkListener workListener)
		throws WorkException {

	Assert.state(this.asyncTaskExecutor != null, "No 'asyncTaskExecutor' set");
	return executeWork(this.asyncTaskExecutor, work, startTimeout, true, executionContext, workListener);
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Test public void testFailingWork() throws Exception {
	pool = new ThreadReuseExecutor("test", 5); //$NON-NLS-1$
	final Semaphore signal = new Semaphore(1);
	pool.execute(new Work() {
		@Override
		public void run() {
			signal.release();
			throw new RuntimeException();
		}
		
		@Override
		public void release() {
			
		}
	});
	assertTrue(signal.tryAcquire(2, TimeUnit.SECONDS));
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
void execute(final Work arg0, final WorkListener arg3, boolean join) throws WorkException {
	if (arg3 != null) {
		arg3.workAccepted(Mockito.mock(WorkEvent.class));
		arg3.workStarted(Mockito.mock(WorkEvent.class));
	}
	
	t = new Thread(new Runnable() {
		
		@Override
		public void run() {
			arg0.run();
			if (arg3 != null) {
				arg3.workCompleted(Mockito.mock(WorkEvent.class));
			}							
		}
	});
	t.start();
	if (join) {
		try {
			t.join();
		} catch (InterruptedException e) {
			throw new WorkException(e);
		}
	}
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
private void invoke(final MessageEndpoint endpoint, final Method m, final Path path) throws WorkException {
	resourceAdapter.getBootstrapContext().getWorkManager().scheduleWork(new Work() {
		
		@Override
		public void run() {
			try {
				Method endpointMethod = endpoint.getClass().getMethod(m.getName(), m.getParameterTypes()); 
				endpoint.beforeDelivery(endpointMethod);
				
				endpointMethod.invoke(endpoint, path.toFile());
				
				endpoint.afterDelivery();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		@Override
		public void release() {}
	});
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * start work 
 *
 * @param e workEvent
 */
@Override
public void workStarted(WorkEvent e)
{
   if (e.getType() != WorkEvent.WORK_STARTED)
      fail("Wrong started type");
   timeStarted = System.currentTimeMillis();
   super.workStarted(e);
   Work work = e.getWork();
   if (work instanceof NestProviderWork)
   {
      NestProviderWork nw = (NestProviderWork) work;
      start.append(nw.getName());
   }

}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * start work 
 *
 * @param e workEvent
 */
@Override
public void workRejected(WorkEvent e)
{
   if (e.getType() != WorkEvent.WORK_REJECTED)
      fail("Wrong rejected type");
   timeRejected = System.currentTimeMillis();
   super.workRejected(e);
   Work work = e.getWork();
   if (work instanceof NestProviderWork)
   {
      NestProviderWork nw = (NestProviderWork) work;
      reject.append(nw.getName());
   }

}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * complete work 
 *
 * @param e workEvent
 */
@Override
public void workCompleted(WorkEvent e)
{
   if (e.getType() != WorkEvent.WORK_COMPLETED)
      fail("Wrong completed type");
   timeCompleted = System.currentTimeMillis();
   super.workCompleted(e);
   Work work = e.getWork();
   if (work instanceof NestProviderWork)
   {
      NestProviderWork nw = (NestProviderWork) work;
      done.append(nw.getName());
      exception = e.getException();
   }

}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void doWork(Work work) throws WorkException
{
   if (policy == null || selector == null || transport == null ||
       work == null || !(work instanceof DistributableWork) || !doWorkDistributionEnabled)
   {
      localDoWork(work);
   }
   else
   {
      doFirstChecks(work, WorkManager.INDEFINITE, null);
      checkTransport();

      DistributableWork dw = (DistributableWork)work;
      boolean executed = false;

      if (policy.shouldDistribute(this, dw))
      {
         Address dwmAddress = selector.selectDistributedWorkManager(getLocalAddress(), dw);
         if (dwmAddress != null && !getLocalAddress().equals(dwmAddress))
         {
            transport.doWork(dwmAddress, dw);
            executed = true;
         }
      }

      if (!executed)
      {
         localDoWork(work);
      }
   }
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * Verify the given work instance.
 * @param work The work
 * @throws WorkException Thrown if a spec compliant issue is found
 */
private void verifyWork(Work work) throws WorkException
{
   Class<? extends Work> workClass = work.getClass();
   String className = workClass.getName();

   if (!validatedWork.contains(className))
   {

      if (isWorkMethodSynchronized(workClass, RUN_METHOD_NAME))
         throw new WorkException(bundle.runMethodIsSynchronized(className));

      if (isWorkMethodSynchronized(workClass, RELEASE_METHOD_NAME))
         throw new WorkException(bundle.releaseMethodIsSynchronized(className));

      validatedWork.add(className);
   }
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
/**
 * Checks, if Work implementation class method is synchronized
 * @param workClass - implementation class
 * @param methodName - could be "run" or "release"
 * @return true, if method is synchronized, false elsewhere
 */
private boolean isWorkMethodSynchronized(Class<? extends Work> workClass, String methodName)
{
   try
   {
      Method method = SecurityActions.getMethod(workClass, methodName, new Class[0]);
      if (Modifier.isSynchronized(method.getModifiers()))
         return true;
   }
   catch (NoSuchMethodException e)
   {
      //Never happens, Work implementation should have these methods
   }

   return false;
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Override
public void doWork(Work work) throws WorkException {
	doWork(work, WorkManager.INDEFINITE, null, null);
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Override
public void scheduleWork(Work work, long startTimeout, ExecutionContext executionContext, WorkListener workListener)
		throws WorkException {

	Assert.state(this.asyncTaskExecutor != null, "No 'asyncTaskExecutor' set");
	executeWork(this.asyncTaskExecutor, work, startTimeout, false, executionContext, workListener);
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Override
public void doWork(Work work, long startTimeout, ExecutionContext executionContext, WorkListener workListener)
		throws WorkException {

	Assert.state(this.syncTaskExecutor != null, "No 'syncTaskExecutor' set");
	executeWork(this.syncTaskExecutor, work, startTimeout, false, executionContext, workListener);
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
@Override
public long startWork(Work work,
                      long l,
                      ExecutionContext executionContext,
                      WorkListener workListener) throws WorkException {
   return 0;
}
 

import javax.resource.spi.work.Work; //导入依赖的package包/类
public void stop() {
	for (int i = 0; this.workList != null && i < this.workList.size(); i++) {
		Work work = this.workList.get(i);
		try {
			work.release();
		} catch (RuntimeException rex) {
			logger.debug(rex.getMessage(), rex);
		}
	}
}