Java TaskExecutor.execute方法代碼示例

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
/**
 * Manages kafka consumers running in a background processing thread for websocket consumers.
 * @param webKafkaConsumerFactory Factory for creating new Consumers
 * @param messagingTemplate messaging template instance for passing websocket messages.
 * @param backgroundConsumerExecutor The executor to run our manager in.
 * @param appProperties defined app properties.
 * @return manager instance for web socket consumers.
 */
@Bean
public WebSocketConsumersManager getWebSocketConsumersManager(
    final WebKafkaConsumerFactory webKafkaConsumerFactory,
    final SimpMessagingTemplate messagingTemplate,
    final TaskExecutor backgroundConsumerExecutor,
    final AppProperties appProperties) {

    // Create manager
    final WebSocketConsumersManager manager = new WebSocketConsumersManager(
        webKafkaConsumerFactory,
        messagingTemplate,
        appProperties.getMaxConcurrentWebSocketConsumers()
    );

    // Submit to executor service
    backgroundConsumerExecutor.execute(manager);

    return manager;
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
public static <T> DeferredResult<T> requestAsync(final TaskExecutor executor,
    final Callable<T> action) {
    final DeferredResult<T> result = new DeferredResult<>();

    final Runnable beforeCallable = () -> {
        try {
            T t = action.call();

            if (result.isSetOrExpired()) {
                log.error("async request expired");
                return;
            }

            result.setResult(t);
        } catch (final Exception ex) {
            result.setErrorResult(ex);
        }
    };

    executor.execute(beforeCallable);
    return result;
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
@Test
public void testGetAsyncExecutor() throws Exception {
  AppConfig config = new AppConfig();
  TaskExecutor asyncExecutor = config.getAsyncExecutor();

  AtomicBoolean value = new AtomicBoolean(false);

  asyncExecutor.execute(() -> {
    try {
      Thread.sleep(250);
    } catch (InterruptedException e) {
    }

    value.set(true);
  });

  Assert.assertFalse(value.get());
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
/**
*  Resumes the execution of this task. The task must be suspended and the method it runs
       *  must be suspendable or exceptions will be thrown.
 *
 *  Note that "resuming" in this case menas only to post a request for resumption by setting the status to ACTIVE.
       *  It is up to the method's compute implementation to check for this status and resume when it is detected.
       *
       *  <p>This method may also wait for the task to resume, but this may lead to the calling thread being
       *  permanently locked if the compute method never finishes.
       *
       *  Note that when second thread calls resume() on the same object, it will have to wait for the first thread to complete the call to this method.
       *
       * @param t executor of this task
       * @throws InvalidTaskStateException thrown when the task status doesn't allow resuming or the method
       *              isn't suspendable
       */
public void resume(TaskExecutor t) throws InvalidTaskStateException {
	synchronized (this) {

		if (!(method instanceof SuspendableMethod) || !status.isResumable()) {
			throw new InvalidTaskStateException("error.taskNotSuspendable");
		}
		status = TaskStatus.ACTIVE;
		info.setResumeTime(new Date());
		fireTaskResumed();
		notifyAll();
		if (t == null) {
			(new Thread(this)).start();
		} else {
			t.execute(this);
		}
		debug("Task resumed");
	}
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
public void copyActivityFeed( final EntityRef connectingEntity, final EntityRef connectedEntityRef )
        throws Exception {
    if (logger.isTraceEnabled()) {
        logger.trace("Copying activities to feed...");
    }
    TaskExecutor taskExecutor = ( TaskExecutor ) getApplicationContext().getBean( "taskExecutor" );
    taskExecutor.execute( new Runnable() {
        @Override
        public void run() {
            try {
                em.copyRelationships( connectedEntityRef, "activities", connectingEntity, "feed" );
            }
            catch ( Exception e ) {
                logger.error( "Error while copying activities into feed", e );
            }
        }
    } );
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
public static boolean execute(Runnable task, long waitTime, TaskExecutor taskExecutor) {
	Assert.notNull(task);

	Counter counter = new Counter("counter for task: " + task);
	Runnable wrapper = new MonitoredRunnable(task, counter);

	boolean internallyManaged = false;

	if (taskExecutor == null) {
		taskExecutor = new SimpleTaskExecutor();
		internallyManaged = true;
	}

	counter.increment();

	taskExecutor.execute(wrapper);

	if (counter.waitForZero(waitTime)) {
		log.error(task + " did not finish in " + waitTime
				+ "ms; consider taking a snapshot and then shutdown the VM in case the thread still hangs");

		//log.error("Current Thread dump***\n" + ThreadDump.dumpThreads());

		if (internallyManaged) {
			try {
				((DisposableBean) taskExecutor).destroy();
			} catch (Exception e) {
				log.error("Exception thrown while destroying internally managed thread executor", e);
			}
		}
		return true;
	}

	return false;
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
@Bean
public CommandLineRunner schedulingRunner(final TaskExecutor executor, final AmqpAdmin amqpAdmin, final ProcessService processStarter) {
    return args -> executor.execute(() -> {
        
        // Init Rabbit exchange and queue
        amqpAdmin.deleteExchange(EXCHANGE);
        TopicExchange exchange = new TopicExchange(EXCHANGE);
        amqpAdmin.declareExchange(exchange);
        Queue queue = new Queue("flowable-history-jobs", true);
        amqpAdmin.declareQueue(queue);
        amqpAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with("flowable-history-jobs"));
      
    });
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
/**
* Prepares starting the execution of the task (the computation) on the new thread if specified TaskExecutor is null, otherwise by this TaskExecutor.
 * Note that "starting" in this case menas only to post a request for starting by setting the status to ACTIVE_WAITING.
       * Note that when second thread calls start() on the same object, it will have to wait for the first thread to complete the call to this method.
       * @param t executor of Task
 * @throws InvalidTaskStateException thrown when the task status doesn't allow starting
 */
public void start(TaskExecutor t) throws InvalidTaskStateException {
	synchronized (this) {
		if (!status.isStartable()) {
			throw new InvalidTaskStateException("error.taskStatusMustBeNew");
		}
		status = TaskStatus.ACTIVE_WAITING;
		if (t == null) {
			(new Thread(this)).start();
		} else {
			t.execute(this);
		}
		debug("Task started");
	}
}
 

import org.springframework.core.task.TaskExecutor; //導入方法依賴的package包/類
public static boolean execute(Runnable task, long waitTime, TaskExecutor taskExecutor) {
	Assert.notNull(task);

	Counter counter = new Counter("counter for task: " + task);
	Runnable wrapper = new MonitoredRunnable(task, counter);

	boolean internallyManaged = false;

	if (taskExecutor == null) {
		taskExecutor = new SimpleTaskExecutor();
		internallyManaged = true;
	}

	counter.increment();

	taskExecutor.execute(wrapper);

	if (counter.waitForZero(waitTime)) {
		log.error(task + " did not finish in " + waitTime
				+ "ms; consider taking a snapshot and then shutdown the VM in case the thread still hangs");

		if (internallyManaged) {
			try {
				((DisposableBean) taskExecutor).destroy();
			}
			catch (Exception e) {
				// no exception is thrown, nothing to worry
			}
		}
		return true;
	}

	return false;
}