在Linux上面运行java程序要比在windows上面跑稳定很多，但是总有些情况下我们的程序跑在了windows上面，这就需要我们对windows server有所了解。今天给大家介绍下如何在windows服务器上面创建定时任务来定时执行java程序。
Windows的有点就是可视化，操作简单，下面一步步为大家演示一下。 
1，首先我们在控制面板中找到“管理工具”，如下图所示： 

2，然后我们打开管理工具，找到其中的“任务计划程序”，如下图所示： 

3，打开任务计划程序，如下图所示： 

4，右击选择“创建基本任务”，这个向导很多简单，适合初学者。如下图所示： 
 
第一步写上任务名称就可以了，然后点击next。
5，接下来是设置触发器，就是什么时候执行，如下图所示： 
 

6，下一步我们设置任务执行什么操作，如下图所示： 

我们选择需要执行的bat文件， 
 
“起始于”选项中一定要填写jar文件的路径，否则会报“Error: Unable to access jarfile”的错误。
7，最后点击“完成”就可以成功创建任务了。 

如果需要在某段时间里面循环执行程序，那我们可以修改触发器的执行时间，如下图所示： 
 
这里我们可以设置两个小时内每5分钟执行一次。
这样到点就会执行我们的java程序，我做这个是用于批量处理数据的。
转载地址：https://blog.csdn.net/shiyong1949/article/details/52779359

PLSQL 创建Oracle定时任务
 
  用语句创建 
 
1、创建任务执行的存储过程，如名称为testJob，向测试表中插入数据，如文章开头，此处省略。
 
 2、创建一个 定时任务 job
 
declare
   job number;
 BEGIN
   DBMS_JOB.SUBMIT(  
         JOB => job,  /*自动生成JOB_ID*/  
         WHAT => 'testJob;',  /*需要执行的存储过程名称或SQL语句*/  
         NEXT_DATE => sysdate,  /*初次执行时间-立即执行*/  
         INTERVAL => 'trunc(sysdate,''mi'')+1/(24*60)' /*每隔1分钟执行一次*/
       );  
   commit;
 end;
 3、查询定时任务相关字段信息
 
select *  from user_jobs;
 
4 、停止定时任务
 
declare
 begin   
   dbms_job.broken(24,true,sysdate);        /*停止一个job,jobId, job的ID,里面参数true也可是false，next_date（某一时刻停止）也可是sysdate（立刻停止）。   */
 commit;
 end;
 5、启动指定定时任务
 
declare
 begin
    DBMS_JOB.RUN(24); /*24 job的id*/
    commit;
 end;
 6、删除定时任务
 
declare
 begin
   dbms_job.remove(24);  /*删除自动执行的job,参数是 job的id*/
   commit;
 end;
 7、修改定时任务的间隔时间
 
declare
 begin
   dbms_job.interval(24,interval => 'TRUNC(SYSDATE)+1');  /*第一个参数为job的ID,第二个参数interval: 计算下一次任务执行的时间表达式*/
   commit;
 end;
 8、修改下一次执行时间
 
declare
 begin
    dbms_job.next_date(24,to_date('2020-11-9 12:08:00','yyyy-mm-dd hh24:mi:ss')); /*第一个参数:job的ID；第二个参数:要修改后的计算下一次执行的时间表达式*/
    commit;
 end;
 9、修改定时任务要执行的操作
 
declare
 begin
     dbms_job.what(24,'testJob2();');   /* 第一个参数:job的ID；第二个参数:要更改的新操作名称（操作名必须存在）*/
 commit;
 end;
 三、结
 
1、dba_jobs 表中字段含义
 
dba_jobs 表中字段含义：
  
 JOB                                         任务的唯一标识码
  
 LOG_USER         提交任务的用户
  
 PRIV_USER         赋予任务权限的用户
  
 SCHEMA_USER           对用户作语法分析的用户模式
  
 LAST_DATE         最后一次成功执行任务的时间
  
 LAST_SEC         最后一次成功执行任务的时间的时分秒
  
 THIS_DATE         正在执行的任务的开始时间，若没有则为空
  
 THIS_SEC 正在执行的任务的开始时间的时分秒，若没有则为空
  
 NEXT_DATE 下一次执行定时任务的时间
  
 NEXT_SEC 下一次执行定时任务的时间的时分秒
  
 TOTAL_TIME 执行当前任务所需要的时间，单位：秒
  
 BROKEN         标志参数，Y表示任务中断，以后不会再运行 
  
 INTERTAL 计算下一次执行定时任务的时间表达式
  
 FAILURES 当前定时任务执行失败的总次数
  
 WHAT 执行任务的PL/SQL代码块
  
 NLS_ENV 任务执行的NLS会话设置
  
 MISC_ENV 定时任务运行的其他一些参数设置
  
 INSTANCE 标识当前任务运行是否受限，0 没有受限
 2、INTERVAL 部分参数值示
 
INTERVAL 部分参数值示例：
  
 每天午夜12点: 'TRUNC(SYSDATE + 1)'
  
 每天早上8点30分: 'TRUNC(SYSDATE + 1) + （8*60+30）/(24*60)'
  
 每星期二中午12点: 'NEXT_DAY(TRUNC(SYSDATE ), ''TUESDAY'' ) + 12/24'
  
 每个月第一天的午夜12点: 'TRUNC(LAST_DAY(SYSDATE ) + 1)'
  
 每个季度最后一天的晚上11点: 'TRUNC(ADD_MONTHS(SYSDATE + 2/24, 3 ), 'Q' ) -1/24'
  
 每星期六和日早上6点10分: 'TRUNC(LEAST(NEXT_DAY(SYSDATE, ''SATURDAY"), NEXT_DAY(SYSDATE, "SUNDAY"))) + （6×60+10）/（24×60）'
  
 每月25号00：00执行: 'TRUNC(LAST_DAY(SYSDATE ) + 25)'
  
 －－－－－－－－－－－－－－－－－－－－－－－－－－
  
 1:每分钟执行
 Interval => TRUNC(sysdate,'mi') + 1/ (24*60)
 或
 Interval => sysdate+1/1440
  
 2:每天定时执行
 例如：每天的凌晨1点执行
 Interval => TRUNC(sysdate) + 1 +1/ (24)
  
  
 3:每周定时执行
 例如：每周一凌晨1点执行
 Interval => TRUNC(next_day(sysdate,'星期一'))+1/24
  
 4:每月定时执行
 例如：每月1日凌晨1点执行
 Interval =>TRUNC(LAST_DAY(SYSDATE))+1+1/24
  
 5:每季度定时执行
 例如每季度的第一天凌晨1点执行
 Interval => TRUNC(ADD_MONTHS(SYSDATE,3),'Q') + 1/24
  
 6:每半年定时执行
 例如：每年7月1日和1月1日凌晨1点
 Interval => ADD_MONTHS(trunc(sysdate,'yyyy'),6)+1/24
  
 7:每年定时执行
 例如：每年1月1日凌晨1点执行
 Interval =>ADD_MONTHS(trunc(sysdate,'yyyy'),12)+1/24
  

静态创建任务
 源代码 xTaskCreateStatic
 静态的方式创建任务，需要用户先申请任务控制模块和任务栈需要的内存（一般使用静态内存），然后把内存地址传递给函数，函数负责其他初始化。
 函数按顺序完成：
 * 根据用户传递内存，初始化任务 TCB
 * 初始化任务堆栈
 * 将新建任务加入到就绪链表中
 * 如果调度器运行，新任务优先级更高，触发系统切换
 
TaskHandle_t xTaskCreateStatic( 
    TaskFunction_t pxTaskCode,
    const char * const pcName,
    const uint32_t ulStackDepth,
    void * const pvParameters,
    UBaseType_t uxPriority,
    StackType_t * const puxStackBuffer,
    StaticTask_t * const pxTaskBuffer )
{
    TCB_t *pxNewTCB;
    TaskHandle_t xReturn;
    configASSERT( puxStackBuffer != NULL );
    configASSERT( pxTaskBuffer != NULL );

    if ((pxTaskBuffer != NULL) && (puxStackBuffer != NULL)) 
    {
        // 设置用户传递进来的任务控制块和栈的内存地址到对应指针变量
        pxNewTCB = (TCB_t *)pxTaskBuffer; 
        pxNewTCB->pxStack = (StackType_t *)puxStackBuffer;

        #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
        {
            // 标识这个任务控制块和栈内存时静态的
            // 删除任务的时候， 系统不会做内存回收处理
            pxNewTCB->ucStaticallyAllocated = 
                tskSTATICALLY_ALLOCATED_STACK_AND_TCB;
        }
        #endif
        // 初始化任务控制块 下文介绍
        prvInitialiseNewTask( pxTaskCode, pcName,
            ulStackDepth, pvParameters, uxPriority, 
            &xReturn, pxNewTCB, NULL );

        // 把新任务插入就绪链表 下文介绍
        prvAddNewTaskToReadyList( pxNewTCB );
    }
    else 
    {
        xReturn = NULL;
    }
    return xReturn;
}
 


 动态创建任务
 源代码 xTaskCreate
 动态创建任务， 调用函数内部向系统申请创建新任务所需的内存，包括任务控制块和栈。 所以调用这个函数，在内存堆空间不足或者碎片话的情况下，可能创建新任务失败，需要判断函数执行后是否成功返回。 其源码解析如下所示。
 
BaseType_t xTaskCreate( 
    TaskFunction_t pxTaskCode,
    const char * const pcName,
    const uint16_t usStackDepth,
    void * const pvParameters,
    UBaseType_t uxPriority,
    TaskHandle_t * const pxCreatedTask )    
{
    TCB_t *pxNewTCB;
    BaseType_t xReturn;

    // 如果是向下增长的栈， 先申请栈内存再申请任务控制块内存
    // 可以避免栈溢出覆盖了自己任务控制块
    // 对应向上增长的则相反

    // 在旧版本 V8.0.0 中没有这么处理，统一先 TCB 后 Stack
    // 项目上碰到平台栈向下增长， 栈溢出错时候覆盖了自己的 TCB 
    // 导致调试的时候无法获取出错任务信息（比如任务名）
    #if( portSTACK_GROWTH > 0 )
    {
        // 申请任务控制块内存
        pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(TCB_t));
        if( pxNewTCB != NULL )
        {
            // 申请栈内存， 返回地址设置任务中的栈指针
            pxNewTCB->pxStack = (StackType_t *)pvPortMalloc(
                (((size_t)usStackDepth) * sizeof(StackType_t)));

            if( pxNewTCB->pxStack == NULL )
            {
                // 栈内存申请失败， 释放前面申请的任务控制块内存
                vPortFree( pxNewTCB );
                pxNewTCB = NULL;
            }
        }
    }
    #else /*栈向下增长*/
    {
        StackType_t *pxStack;
        pxStack = (StackType_t *)pvPortMalloc(
            (((size_t)usStackDepth) * sizeof(StackType_t)));

        if( pxStack != NULL )
        {
            pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(TCB_t));
            if( pxNewTCB != NULL )
            {
                pxNewTCB->pxStack = pxStack;
            }
            else
            {
                vPortFree( pxStack );
            }
        }
        else
        {
            pxNewTCB = NULL;
        }
    }
    #endif


    if( pxNewTCB != NULL )
    {
        // 成功申请所需内存 执行任务初始化操作

        #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
        {
            // 标志任务控制块和栈是动态申请
            // 删除任务系统会自动回收内存
            pxNewTCB->ucStaticallyAllocated = 
                tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */

        // 初始任务控制块
        prvInitialiseNewTask(pxTaskCode, pcName,
            (uint32_t)usStackDepth, pvParameters, 
            uxPriority, pxCreatedTask, pxNewTCB, NULL );

        // 将新任务插入到就绪链表  
        prvAddNewTaskToReadyList( pxNewTCB );
        xReturn = pdPASS;
    }
    else
    {
        // 创建任务失败，返回错误码
        xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
    }
    return xReturn;
}
 

  

创建了两个单独的任务并打印不同的信息。
 
1、头文件声明
 
#include "FreeRTOS.h"
#include "task.h"
#include "supporting_functions.h"

// 延时
#define mainDELAY_LOOP_COUNT        ( 0xffffff )
 
2、任务函数声明
 
void vTask1( void *pvParameters );
void vTask2( void *pvParameters );
 
3、创建任务
 
int main( void )
{
    // 创建任务1
    xTaskCreate(    vTask1,        /* 任务函数指针 */
                    "Task 1",               /* 任务名：调试使用 */
                    1000,                    /* 栈深 */
                    NULL,                   /* 任务参数 */
                    1,                          /* 优先级. */
                    NULL );                /* 任务 handle */

   // 创建任务2
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );

    // 启动任务调动
    vTaskStartScheduler(); 
    for( ;; );
    return 0;
}

// 任务1

void vTask1( void *pvParameters )
{
   const char *pcTaskName = "Task 1 is running\r\n";
   volatile uint32_t ul;
    for( ;; )
    {
        // 打印
        vPrintString( pcTaskName );

       // 延时
        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
        {}
    }
}


// 任务2

void vTask2( void *pvParameters )
{
  const char *pcTaskName = "Task 2 is running\r\n";
  volatile uint32_t ul；


    for( ;; )
    {
       // 打印
        vPrintString( pcTaskName );

        // 延时
        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
        {} 
    }
}