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"/>}

//上一次調用完之后，五秒再調用一次,依此循環(huán)下去
@Scheduled(fixedDelay=5000)
public void doSomething() {
 // something that should execute periodically
}
//連續(xù)的每次調用開始時間之間，間隔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注釋的方法不同，這些方法可以預期參數(shù).
//因為調用方將在運行時以“正常”方式調用它們，而不是從容器管理的調度任務中調用。
@Async
void doSomething(String s) {
 // this will be executed asynchronously
}

// 具有Future回調返回值
//執(zhí)行其它任務的優(yōu)先級 依然是高于執(zhí)行回調的優(yōu)先級。
@Async
Future<String> returnSomething(int i) {
 // this will be executed asynchronously
}

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

<!-- 默認創(chuàng)建一個指定大小的ThreadPoolTaskScheduler -->
<task:scheduler id="scheduler" pool-size="10"/>

<!-- 創(chuàng)建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"/><!-- 任務拒絕策略（強制任務提交線程執(zhí)行任務，從而限制傳入負載變得過大） 默認的是直接拋出異常-->

<task:scheduled-tasks scheduler="myScheduler">
<task:scheduled ref="beanA" method="methodA" fixed-delay="5000"/><!--ref
指向容器管理的對象，method是要執(zhí)行的方法名-->
</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"/><!--第一次執(zhí)行延遲一秒，以后每次上一個任務完成后 再執(zhí)行-->
<task:scheduled ref="beanB" method="methodB" fixed-rate="5000"/>
<!--固定頻率執(zhí)行 如果上一個任務執(zhí)行時間超時，第二個任務會立即執(zhí)行 -->
<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" />
<!--并發(fā)執(zhí)行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 * * ?" />
<!-- 每天早上六點執(zhí)行-->
</bean>