一文详解Spring任务执行和调度(小结)

public class TaskExecutorExample {
 private class MessagePrinterTask implements Runnable {
  private String message;
  public MessagePrinterTask(String message) {
   this.message = message;
  }
  public void run() {
   System.out.println(message);
  }
 }
 private TaskExecutor taskExecutor;
 public TaskExecutorExample(TaskExecutor taskExecutor) {
  this.taskExecutor = taskExecutor;
 }
 public void printMessages() {
  for (int i = 0; i < 25; i++) {
   taskExecutor.execute(new MessagePrinterTask("Message" + i));
  }
 }
}

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent
.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="5" />
<property name="maxPoolSize" value="10" />
<property name="queueCapacity" value="25" />
</bean>
<bean id="taskExecutorExample" class="cn.pconline.activity.task.TaskExecutorExample" init-method="printMessages">
<constructor-arg ref="taskExecutor" />
</bean>

public interface TaskScheduler {
 ScheduledFuture schedule(Runnable task, Trigger trigger);
 ScheduledFuture schedule(Runnable task, Date startTime);
 ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);
 ScheduledFuture scheduleAtFixedRate(Runnable task, long period);
 ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
 ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}

public interface Trigger {
 Date nextExecutionTime(TriggerContext triggerContext);
}
public interface TriggerContext {
 Date lastScheduledExecutionTime();
 Date lastActualExecutionTime();
 Date lastCompletionTime();
}

scheduler.schedule(task, new CronTrigger(" 15 9-17 * MON-FRI"));

@Configuration
@EnableAsync
@EnableSCheduling
public class AppConfig {
}

<task:annotation-driven executor="myExecutor" scheduler="myScheduler"/>
<task:executor id="myExecutor" pool-size="5"/>
<task:scheduler id="myScheduler" pool-size="10"/>}

//上一次调用完之后，五秒再调用一次,依此循环下去
@Scheduled(fixedDelay=5000)
public void doSomething() {
 // something that should execute periodically
}
//连续的每次调用开始时间之间，间隔5s
@Scheduled(fixedRate=5000)
public void doSomething() {
 // something that should execute periodically
}
//
@Scheduled(cron="*/5 * * * * MON-FRI")
public void doSomething() {
 // something that should execute on weekdays only
}

@Async
void doSomething() {
 // this will be executed asynchronously
}

/@Scheduled注释的方法不同，这些方法可以预期参数.
//因为调用方将在运行时以“正常”方式调用它们，而不是从容器管理的调度任务中调用。
@Async
void doSomething(String s) {
 // this will be executed asynchronously
}

// 具有Future回调返回值
//执行其它任务的优先级 依然是高于执行回调的优先级。
@Async
Future<String> returnSomething(int i) {
 // this will be executed asynchronously
}

@Async("otherExecutor")
void doSomething(String s) {
 // this will be executed asynchronously by "otherExecutor"
}

<!-- 默认创建一个指定大小的ThreadPoolTaskScheduler -->
<task:scheduler id="scheduler" pool-size="10"/>

<!-- 创建ThreadPoolTaskExecutor实例 -->
<task:executor id="executor" pool-size="10"/>

<task:executor id="executorWithPoolSizeRange"
pool-size="5-25"
queue-capacity="100"/><!-- 指定队列的大小-->

<task:executor id="executorWithCallerRunsPolicy"
pool-size="5-25"
queue-capacity="100"
rejection-policy="CALLER_RUNS"/><!-- 任务拒绝策略（强制任务提交线程执行任务，从而限制传入负载变得过大） 默认的是直接抛出异常-->

<task:scheduled-tasks scheduler="myScheduler">
<task:scheduled ref="beanA" method="methodA" fixed-delay="5000"/><!--ref
指向容器管理的对象，method是要执行的方法名-->
</task:scheduled-tasks>

<task:scheduler id="myScheduler" pool-size="10"/>
<task:scheduled-tasks scheduler="myScheduler">
<task:scheduled ref="beanA" method="methodA" fixed-delay="5000" initial-delay="1000"/><!--第一次执行延迟一秒，以后每次上一个任务完成后 再执行-->
<task:scheduled ref="beanB" method="methodB" fixed-rate="5000"/>
<!--固定频率执行 如果上一个任务执行时间超时，第二个任务会立即执行 -->
<task:scheduled ref="beanC" method="methodC" cron="*/5 * * * * MON-FRI"/>
</task:scheduled-tasks>
<task:scheduler id="myScheduler" pool-size="10"/>

<bean name="exampleJob" class="org.springframework.scheduling
.quartz.JobDetailBean">
<property name="jobClass" value="example.ExampleJob" />
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="5" />
</map>
</property>
</bean>

package example;
public class ExampleJob extends QuartzJobBean {
 private int timeout;
 /**
* Setter called after the ExampleJob is instantiated
* with the value from the JobDetailBean (5)
*/
 public void setTimeout(int timeout) {
  this.timeout = timeout;
 }
 protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
  // do the actual work
 }
}

<bean id="jobDetail" class="org.springframework.scheduling.quartz
.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="exampleBusinessObject" />
<property name="targetMethod" value="doIt" />
</bean>

<bean id="exampleBusinessObject" class="examples.ExampleBusinessObject"/>

public class ExampleBusinessObject {
 // properties and collaborators
 public void doIt() {
  // do the actual work
 }
}

<bean id="jobDetail" class="org.springframework.scheduling.quartz
.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="exampleBusinessObject" />
<property name="targetMethod" value="doIt" />
<property name="concurrent" value="false" />
<!--并发执行false-->
</bean>

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz
.SimpleTriggerFactoryBean">
<!-- see the example of method invoking job above -->
<property name="jobDetail" ref="jobDetail" />
<!-- 10 seconds -->
<property name="startDelay" value="10000" />
<!-- repeat every 50 seconds -->
<property name="repeatInterval" value="50000" />
</bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz
.CronTriggerFactoryBean">
<property name="jobDetail" ref="exampleJob" />
<!-- run every morning at 6 AM -->
<property name="cronExpression" value="0 0 6 * * ?" />
<!-- 每天早上六点执行-->
</bean>