常用定时器框架

最新推荐文章于 2024-08-17 19:38:58 发布
最新推荐文章于 2024-08-17 19:38:58 发布
阅读量903 收藏
点赞数

/*

  • 刷新管理器
  • @处理定时任务
  • @统一刷新回调机制
  • @处理倒计时(防后台)
    */

using UnityEngine;
using System.Collections.Generic;
using System.Collections;
using System;
using LogPrint;

public class TimeManager : MonoBehaviour
{
///
/// 全局实例
///
private static TimeManager _Instance = null;

/// <summary>
/// 定时器字典
/// </summary>
private Dictionary<string, Timer> m_TimerList = new Dictionary<string, Timer>();

/// <summary>
///   增加队列
/// </summary>
private Dictionary<string, Timer> m_AddTimerList = new Dictionary<string, Timer>();

/// <summary>
///   销毁队列
/// </summary>5069726163792e
private List<string> m_DestroyTimerList = new List<string>();

public delegate void TimerManagerHandler();

public delegate void TimerManagerHandlerArgs(params object[] args);



/// <summary>e5adabe38aa3e58189
/// 倒计时回调
/// </summary>
/// <param name="count">倒计时剩余时间</param>
/// <param name="args">倒计时参数</param>
public delegate void TimerManagerCountHandlerArgs(int count, params object[] args);

/// -----------------------------------------------------------------------------
/// <summary>
/// 全局实例
/// </summary>
/// -----------------------------------------------------------------------------
public static TimeManager Instance
{
    get
    {
        if (_Instance == null)
        {
            _Instance = FindObjectOfType(typeof(TimeManager)) as TimeManager;
        }

        return _Instance;
    }
}

// Use this for initialization
void Awake()
{
    if (TimeManager.Instance != null && TimeManager.Instance != this)
    {
        UnityEngine.Object.Destroy(this);
        return;
    }

    _Instance = this;
}

#region 刷新器管理
Dictionary<string, Timer>.Enumerator it;
Dictionary<string, Timer>.Enumerator itAdd;
// Update is called once per frame
void Update()
{
    if (m_DestroyTimerList.Count > 0)
    {
        ///>从销毁队列中销毁指定内容
        //foreach (string i in m_DestroyTimerList)
        //{
        //    m_TimerList.Remove(i);
        //}

        for (int i = 0; i < m_DestroyTimerList.Count; i++)
        {
            m_TimerList.Remove(m_DestroyTimerList[i]);
        }
        //清空
        m_DestroyTimerList.Clear();
    }

    if (m_AddTimerList.Count > 0)
    {
        ///>从增加队列中增加定时器
        itAdd = m_AddTimerList.GetEnumerator();
        while (itAdd.MoveNext())
        {
            if (itAdd.Current.Value == null)
                continue;

            if (m_TimerList.ContainsKey(itAdd.Current.Key))
            {
                m_TimerList[itAdd.Current.Key] = itAdd.Current.Value;
            }
            else
            {
                m_TimerList.Add(itAdd.Current.Key, itAdd.Current.Value);
            }
        }
        //清空
        m_AddTimerList.Clear();
    }

    //响应定时器
    if (m_TimerList.Count > 0)
    {
        it = m_TimerList.GetEnumerator();
        while (it.MoveNext())
        {
            if (it.Current.Value == null)
                return;

            it.Current.Value.Run();
        }
    }
}

/// -----------------------------------------------------------------------------
/// <summary>
/// 增加刷新器
/// </summary>
/// <param name=""></param>
/// <returns></returns>
/// -----------------------------------------------------------------------------
public bool AddTimer(string key, float duration, TimerManagerHandler handler)
{
    return Internal_AddTimer(key, TIMER_MODE.NORMAL, duration, handler);
}
public bool AddTimer(string key, float duration, TimerManagerHandlerArgs handler, params object[] args)
{
    return Internal_AddTimer(key, TIMER_MODE.NORMAL, duration, handler, args);
}


/// -----------------------------------------------------------------------------
/// <summary>
/// 增加持续刷新器
/// </summary>
/// <param name=""></param>
/// <returns></returns>
/// -----------------------------------------------------------------------------
public bool AddTimerRepeat(string key, float duration, TimerManagerHandler handler)
{
    return Internal_AddTimer(key, TIMER_MODE.REPEAT, duration, handler);
}
public bool AddTimerRepeat(string key, float duration, TimerManagerHandlerArgs handler, params object[] args)
{
    return Internal_AddTimer(key, TIMER_MODE.REPEAT, duration, handler, args);
}

/// <summary>
/// 刷新倒计时
/// </summary>
/// <param name="key">标记字符</param>
/// <param name="duration">倒计时时间</param>
/// <param name="handler">计时回调</param>
/// <param name="args">计时参数</param>
/// <returns></returns>
public bool AddTimerCount(string key, float duration, TimerManagerCountHandlerArgs handler, params object[] args)
{
    return Internal_AddTimer(key, TIMER_MODE.COUNTTIME, duration, 1, (int)duration, handler, args);
}

/// <summary>
/// 刷新倒计时
/// </summary>
/// <param name="key">标记字符</param>
/// <param name="duration">倒计时时间</param>
/// <param name="totalTime">总次数</param>
/// <param name="handler">计时回调</param>
/// <param name="args">计时参数</param>
public bool AddTimerCount(string key, float eachTime, int totalTime, TimerManagerCountHandlerArgs handler, params object[] args)
{
    float totalTimed = eachTime * totalTime;
    return Internal_AddTimer(key, TIMER_MODE.COUNTTIME, totalTimed, eachTime, totalTime, handler, args);
}


/// <summary>
/// 销毁带有前缀的所有刷新器
/// </summary>
/// <param name="prefix"></param>
public void ClearTimerWithPrefix(string prefix)
{
    if (m_TimerList != null && m_TimerList.Count > 0)
    {
        foreach (string timerKey in m_TimerList.Keys)
        {
            if (timerKey.StartsWith(prefix))
            {
                Destroy(timerKey);
            }
        }
    }
}

/// -----------------------------------------------------------------------------
/// <summary>
/// 销毁指定定时器
/// </summary>
/// <param name="key">标识符</param>
/// <returns></returns>
/// -----------------------------------------------------------------------------
public bool Destroy(string key)
{
    if (m_AddTimerList.ContainsKey(key))
    {
        m_AddTimerList.Remove(key);
    }

    if (!m_TimerList.ContainsKey(key))
    {
        return false;
    }

    if (!m_DestroyTimerList.Contains(key))
    {
        m_DestroyTimerList.Add(key);
    }

    return true;
}

/// <summary>
/// 是否含用定时器
/// </summary>
/// <returns><c>true</c> if this instance is have timer the specified key; otherwise, <c>false</c>.</returns>
/// <param name="key">Key.</param>
public bool IsHaveTimer(string key)
{
    // 待添加队里中有
    if (m_AddTimerList.ContainsKey(key))
    {
        return true;
    }

    // 正在运行阶段
    if (!m_DestroyTimerList.Contains(key) && m_TimerList.ContainsKey(key))
    {
        return true;
    }

    return false;
}

/// -----------------------------------------------------------------------------
/// <summary>
/// 增加定时器
/// </summary>
/// <param name=""></param>
/// <returns></returns>
/// -----------------------------------------------------------------------------
private bool Internal_AddTimer(string key, TIMER_MODE mode, float duration, TimerManagerHandler handler)
{
    if (string.IsNullOrEmpty(key))
        return false;

    if (duration < 0.0f)
        return false;

    Timer timer = new Timer(key, mode, Time.realtimeSinceStartup, duration, handler, this);

    if (m_AddTimerList.ContainsKey(key))
    {
        m_AddTimerList[key] = timer;
    }
    else
    {
        m_AddTimerList.Add(key, timer);
    }

    if (GameDefault.Instance.Debug)
    {
        SetTimeScale(key);
    }

    return true;
}

private bool Internal_AddTimer(string key, TIMER_MODE mode, float duration, TimerManagerHandlerArgs handler, params object[] args)
{
    if (string.IsNullOrEmpty(key))
        return false;

    if (duration < 0.0f)
        return false;

    Timer timer = new Timer(key, mode, Time.realtimeSinceStartup, duration, handler, this, args);

    if (m_AddTimerList.ContainsKey(key))
    {
        m_AddTimerList[key] = timer;
    }
    else
    {
        m_AddTimerList.Add(key, timer);
    }

    return true;
}

private bool Internal_AddTimer(string key, TIMER_MODE mode, float duration, float eachTime, int count, TimerManagerCountHandlerArgs handler, params object[] args)
{
    if (string.IsNullOrEmpty(key))
        return false;

    if (duration < 0.0f)
        return false;

    Timer timer = new Timer(key, mode, Time.time, duration, eachTime, count, handler, this, args);

    if (m_AddTimerList.ContainsKey(key))
    {
        m_AddTimerList[key] = timer;
    }
    else
    {
        m_AddTimerList.Add(key, timer);
    }

    return true;
}

public bool IsRunning(string key)
{
    return m_TimerList.ContainsKey(key);
}

public int getTimeCount(string key)
{
    if (m_TimerList.ContainsKey(key))
    {
        return m_TimerList[key].Count;
    }
    return 0;
}

/// -----------------------------------------------------------------------------
/// <summary>
///  定时器模式
/// </summary>
/// -----------------------------------------------------------------------------
public enum TIMER_MODE
{
    NORMAL,
    REPEAT,
    COUNTTIME,
}

public class Timer
{
    /// <summary>
    ///   名称
    /// </summary>
    private string m_Name;

    /// <summary>
    ///   模式
    /// </summary>
    private TIMER_MODE m_Mode;

    /// <summary>
    ///   开始时间
    /// </summary>
    public float m_StartTime;

    /// <summary>
    ///   时长
    /// </summary>
    public float m_duration;
    /// <summary>
    ///   单次时长
    /// </summary>
    private float m_eachTime;
    /// <summary>
    ///   总次数
    /// </summary>
    private int m_Count;

    /// <summary>
    ///  中断
    /// </summary>
    private bool m_Break = false;

    /// <summary>
    ///  中断开始时间
    /// </summary>
    private float m_BreakStart;

    /// <summary>
    ///  中断开始时间
    /// </summary>
    private float m_BreakDuration = 0;

    /// <summary>
    ///   时间点
    /// </summary>
    public float m_time = 0;

    private bool timeScale = false;

    /// <summary>
    /// 是否缩放时间
    /// </summary>
    public bool TimeScale
    {
        get { return timeScale; }
        set { timeScale = value; }
    }

    /// <summary>
    ///   定时器委托
    /// </summary>
    private TimerManagerHandler m_TimerEvent;

    private TimerManagerHandlerArgs m_TimerArgsEvent;

    private TimerManagerCountHandlerArgs m_TimerCountArgsEvent;

    private TimeManager m_Manger;

    private object[] m_Args = null;

    /// -----------------------------------------------------------------------------
    /// <summary>
    /// 开始时间
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    /// -----------------------------------------------------------------------------
    public float StartTime
    {
        get
        {
            return m_StartTime;
        }
        set
        {
            m_StartTime = value;
        }
    }

    /// -----------------------------------------------------------------------------
    /// <summary>
    /// 剩余时间
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    /// -----------------------------------------------------------------------------
    public float TimeLeft
    {
        get
        {
            return Mathf.Max(0.0f, m_duration - (timeScale ? Time.time - m_StartTime : Time.realtimeSinceStartup - m_StartTime));
        }
    }

    /// -----------------------------------------------------------------------------
    /// <summary>
    /// 
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    /// -----------------------------------------------------------------------------
    public Timer(string name, TIMER_MODE mode, float startTime, float duration, TimerManagerHandler handler, TimeManager manager)
    {
        m_Name = name;
        m_Mode = mode;
        m_StartTime = startTime;
        m_duration = duration;
        m_TimerEvent = handler;
        m_Manger = manager;
    }

    public Timer(string name, TIMER_MODE mode, float startTime, float duration, TimerManagerHandlerArgs handler, TimeManager manager, params object[] args)
    {
        m_Name = name;
        m_Mode = mode;
        m_StartTime = startTime;
        m_duration = duration;
        m_TimerArgsEvent = handler;
        m_Manger = manager;
        m_Args = args;
    }

    public Timer(string name, TIMER_MODE mode, float startTime, float duration, float eachTime, int count, TimerManagerCountHandlerArgs handler, TimeManager manager, params object[] args)
    {
        m_time = Time.realtimeSinceStartup;
        m_Name = name;
        m_Mode = mode;
        m_StartTime = startTime;
        m_duration = duration;
        m_eachTime = eachTime;
        m_Count = count;
        m_TimerCountArgsEvent = handler;
        m_Manger = manager;
        m_Args = args;
    }

    public Timer(string name, TIMER_MODE mode, float startTime, float duration, TimerManagerCountHandlerArgs handler, TimeManager manager, params object[] args)
    {
        m_time = Time.realtimeSinceStartup;
        m_Name = name;
        m_Mode = mode;
        m_StartTime = startTime;
        m_duration = duration;
        m_TimerCountArgsEvent = handler;
        m_Manger = manager;
        m_Args = args;
    }

    /// -----------------------------------------------------------------------------
    /// <summary>
    /// 运行事件
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    /// -----------------------------------------------------------------------------
    public void Run()
    {
        if (m_Break) return;

        if (m_Mode == TIMER_MODE.COUNTTIME)
        {
            float lastTime = timeScale ? Time.time - m_time : Time.realtimeSinceStartup - m_time;
            if (lastTime - m_eachTime >= 0.03f)
            {
                m_time = timeScale ? Time.time : Time.realtimeSinceStartup;
                if (this.m_TimerCountArgsEvent != null)
                {
                    m_Count--;
                    this.m_TimerCountArgsEvent(m_Count, m_Args);
                }

                //if (this.TimeLeft < m_eachTime)
                //{
                //    m_Manger.Destroy(this.m_Name);
                //}

                if (m_Count <= 0)
                {
                    m_Manger.Destroy(this.m_Name);
                }
            }
            return;
        }

        if (this.TimeLeft > 0.0f)
            return;

        if (m_Mode == TIMER_MODE.NORMAL)
        {
            m_Manger.Destroy(this.m_Name);
        }
        else
        {
            m_StartTime = timeScale ? Time.time : Time.realtimeSinceStartup;
        }

        if (this.m_TimerEvent != null)
        {
            this.m_TimerEvent();
        }
        if (this.m_TimerArgsEvent != null)
        {
            this.m_TimerArgsEvent(m_Args);
        }
    }
    public void Break()
    {
        if (m_Break)
        {
            return;
        }

        m_Break = true;
        m_BreakStart = Time.realtimeSinceStartup;
    }

    public void Resume()
    {
        if (!m_Break)
        {
            return;
        }

        m_BreakDuration += (Time.realtimeSinceStartup - m_BreakStart);
        m_Break = false;
    }

    public float RealTime()
    {
        return Time.realtimeSinceStartup - m_BreakDuration;
    }

    public int Count
    {
        get { return m_Count; }
    }
}

internal void AddTimer(string v, object moveredtwo)
{
    throw new NotImplementedException();
}

public Timer GetTimer(string key)
{
    if (m_TimerList.ContainsKey(key))
        return m_TimerList[key];

    return null;
}

/// <summary>
/// 暂停带有前缀的所有定时器
/// </summary>
/// <param name="prefix"></param>
public void BreakTimerWithPrefix(string prefix)
{
    if (m_TimerList != null && m_TimerList.Count > 0)
    {
        string[] arr = new string[m_TimerList.Count];
        m_TimerList.Keys.CopyTo(arr, 0);

        for (int i = 0; i < arr.Length; i++)
        {
            if (arr[i].StartsWith(prefix))
            {
                BreakTimer(arr[i]);
            }
        }
    }
}

/// <summary>
/// 暂停计时器
/// </summary>
public void BreakTimer(string key)
{
    if (m_TimerList.ContainsKey(key))
    {
        Timer timer = m_TimerList[key];
        timer.Break();
    }
    else
    {
        if (m_AddTimerList.ContainsKey(key))
        {
            Timer timer = m_AddTimerList[key];
            timer.Break();
        }
    }
}

/// <summary>
/// 重启带有前缀的所有定时器
/// </summary>
/// <param name="prefix"></param>
public void ResumeTimerWithPrefix(string prefix)
{
    if (m_TimerList != null && m_TimerList.Count > 0)
    {
        string[] arr = new string[m_TimerList.Count];
        m_TimerList.Keys.CopyTo(arr, 0);

        for (int i = 0; i < arr.Length; i++)
        {
            if (arr[i].StartsWith(prefix))
            {
                ResumeTimer(arr[i]);
            }
        }
    }
}

/// <summary>
/// 重启计时器
/// </summary>
public void ResumeTimer(string key)
{
    if (m_TimerList.ContainsKey(key))
    {
        Timer timer = m_TimerList[key];
        timer.Resume();
    }
    else
    {
        if (m_AddTimerList.ContainsKey(key))
        {
            Timer timer = m_AddTimerList[key];
            timer.Resume();
        }
    }
}

/// <summary>
/// 获取实际游戏时间
/// </summary>
public float RealGameTime(string key)
{
    if (!m_TimerList.ContainsKey(key))
    {
        return 0f;
    }

    Timer timer = m_TimerList[key];
    return timer.RealTime();
}

/// <summary>
/// 设置计时器受定帧影响
/// </summary>
public void SetTimeScale(string key)
{
    if (!m_AddTimerList.ContainsKey(key))
    {
        LogSystem.LogError("not contains key: " + key);
        return;
    }

    Timer timer = m_AddTimerList[key];
    timer.TimeScale = true;
    timer.m_time = Time.time;
    timer.m_StartTime = Time.time;
}


#endregion

#region 全局定帧

/// <summary>
/// 全局定帧
/// </summary>
/// <param name="slowRate">速度比率</param>
/// <param name="slowTime">定帧时间</param>
public void SlowGamePlay(int slowRate, float slowTime = 0f)
{
    Destroy("SlowGamePlay");
    if (slowRate == 0)
    {
        Time.timeScale = 0;
        return;
    }
    if (slowRate == 100)
    {
        Time.timeScale = 1;
        return;
    }

    Time.timeScale = slowRate * 0.01f;
    AddTimer("SlowGamePlay", slowTime, () =>
    {
        Time.timeScale = 1;
    });


}

/// <summary>
/// 继续游戏
/// </summary>
public void PlayGame()
{
    Time.timeScale = 1;
}

/// <summary>
/// 暂停游戏
/// </summary>
public void PauseGame()
{
    Time.timeScale = 0;
}

#endregion

public static IEnumerator DelayToInvokeDo(Action action, float delaySeconds)
{
    yield return new WaitForSeconds(delaySeconds);
    action();
}

}

keren2
关注
Java定时器框架(Quartz)
12-23
有助于你快速的查找您要使用的类对象及其方法。
一个java定时器框架
dato0123
02-25 96
ScheduleIterator接口&lt;?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /&gt; importjava.util.Date;publicinterfaceScheduleIterator{publicDatenext();//获取下一个触发的时间点} Scheduler类 ...
若依框架-功能详解_定时任务
最新发布
m0_74462339的博客
08-17 1783
但特殊的场景：关闭订单做退款，这两个任务是先关闭订单再做退款，即先执行A再执行B,如果允许并发执行，万一A失败了，B却执行了，即订单没关，钱却退了，这显然不合理，直接让客户白嫖了，所以针对这个特殊的场景，应该关闭并发执行。，它会执行因为宕机而没有执行的最后一个任务，在这里指的是9点执行的任务，在此之前的任务都不会执行，之后继续执行后面的任务9点半、10点、10点半等等）。，则宕机期间未执行的任务，都不会执行，而是直接执行后面的任务9点半、10点、10点半等等）。每间隔五秒，控制台输出系统时间。
JAVA 定时器框架
baidu_36415076的博客
11-16 1092
web.xml<display-name>XXX Web Application</display-name> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/conf/frame-spring.xml <
java 定时器框架_一个java定时器框架
weixin_42367557的博客
02-16 81
ScheduleIterator接口importjava.util.Date;publicinterfaceScheduleIterator{publicDatenext();//获取下一个触发的时间点}Scheduler类importjava.util.Date;importjava.util.Timer;importjava.util.TimerTask;publicclas...
java 定时器框架_java定时器
weixin_39648539的博客
02-24 176
java定时器什么是Java定时器？Java 定时器就是在给定的间隔时间执行自己的任务; Java实现定时器有以下几种:通过Timer来实现定时任务Timer 是来自 java.util.Timer指定时间执行任务/*** @author spp* @date 2020-10-14 09:04**/public class TimerTest {public static void main(St...
MSP430单片机常用程序框架
08-03
以下是对MSP430单片机常用程序框架的详细解释： 1. 循环低功耗、中断服务程序唤醒 这种程序框架的主要特点是利用中断服务程序来唤醒单片机从低功耗模式。在`main()`函数中，首先关闭看门狗定时器，初始化时钟、端口...
verilog定时器_定时器_verilog_verilog定时器_verilog定时_doingmco_
10-03
以下是一个简化的 Verilog 代码示例，展示了一个基本的定时器框架： ```verilog module timer ( input wire clk, // 时钟信号 input wire reset_n, // 异步低电平复位 input wire start, // 开始计时信号 input...
MFC高精度定时器，多媒体定时器，VS2019,C++
01-25
6. `framework.h`：自定义的框架头文件，可能包含了项目中常用的函数和类定义。 7. `resource.h`：资源头文件，包含了对话框、菜单、图标等资源的ID定义。 要在MFC应用中实现多媒体定时器，首先需要在`timeset.cpp`...
QT在子线程中调用定时器
09-08
在这里，我们主要关注`QTimer`，因为它是最常用的定时器类型，支持单次触发和周期性触发。`QTimer`基于信号和槽机制，当定时器触发时，会发射`timeout()`信号，你可以连接这个信号到相应的槽函数以执行特定的任务。 ...
spring定时器
10-20
#### 三、Spring 定时器常用属性解析 - **cron**：使用Cron表达式来定义任务执行的时间间隔。Cron表达式是一个字符串，由六个或七个字段组成，每个字段之间用空格分隔。 - **fixedRate**：设置固定的执行间隔时间...
Android-TimeTask是一个轻量简洁的定时任务队列框架
08-13
TimeTask是一个轻量简洁的定时任务队列框架,专注处理多组任务分发工作 TimeTask内部的实现时基于AlarmManager 广播，在任务与系统api中间做了较好的封装
4.3定时器框架（Timer Framework）
owen_william的博客
08-30 996
经常需要为一个简短的执行（这任务只执行一次）安排时间列任务（一个单位的任务）或在制定的规则中重复执行。例如，你可能安排一个闹钟任务去运行一次（可能在早上唤醒这个任务），或安排一个夜间回滚任务在时间间隔中执行。对于任何一种任务，你能想要任务在特殊时间执行，或在将来或初始化的延迟时间执行。     你可以使用Thread和连接一个风格去创建一个框架来完成任务时间安排表。然后，Java1.3介绍一个更
定时器：Quartz框架
m0_51736969的博客
03-16 539
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域的开源项目，是由 java 开发的一个开源的任务日程管理系统。Quartz 是一个功能丰富的开源作业调度库，几乎可以集成到任何 Java 应用程序中——从最小的独立应用程序到最大的电子商务系统。Quartz 可用于创建简单或复杂的调度，以执行数十、数百甚至数万个作业；任务被定义为标准 Java 组件的作业，这些组件几乎可以执行任何您可以对其编程来执行的操作。
Quartz-计时器框架
五谷丰登
10-18 255
Quartz体系结构： 明白Quartz怎么用，首先要了解==Scheduler(调度器)、Job(任务)和Trigger(触发器)==这3个核心的概念。 1.Scheduler： 代表一个Quartz的独立运行容器， Trigger和JobDetail可以注册到Scheduler中， 两者在Scheduler中拥有各自的组及名称， 组及名称是Scheduler查找定位容器中某一对象的依据， Tr...
ET框架之自写模块SmartTimerModule
b663455888378594的博客
08-20 281
1.代码结构图 2.SmartTimer 模块Entity： 1 using System; 2 3 namespace ETModel 4 { 5 [ObjectSystem] 6 public class SmartTimerAwakeSystem: AwakeSystem<SmartTimer, float,...
0612~quartz定时器框架
m0_67574688的博客
06-12 390
今天老师讲的定时器框架,quartz~简单易学 但不适合高并发;quartz主要由:1.trigger触发器, 2.job detail 业务详情, 两部分组成scheduler容器；适用场景: 1.定时发邮件; 2.定时发报表; 3.定时关闭支付订单； 4.一系列定时操作都可以完成,功能强大;实战关闭订单的功能实现;1.配置动态
定时任务框架Quartz
weixin_43139147的博客
05-28 2203
在Spring Boot 中要实现定时任务，有两中方案，一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解，另一种就是使用Quartz。 1.Scheduled 这种用法非常简单，涉及到的业务非常简单是可以使用该用法。 2.Quartz quartz的核心类有以下三个需要牢记： 调度器：Scheduler 触发器：Trigger 作业类：JobDetail 该图片用了DistressRroke _chen的文章中的图片 详细见：https...
quartz 一个Java的定时器框架 入门心得
巴休特的风之剑
10-23 275
quartz是一个定时器框架，可以用它在java里做些什么？ 比如，每天 00.00.00 时服务器刷新缓存，清除已过期的数据，或是每到各种节日，固定给user发送祝福消息提醒。 话不多说，首先下载jar包： //定时器 quartz compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.3.0...
Qt框架常用类详解
以下是一些Qt框架中常用的类及其功能的中文介绍： 1. **QAbstractButton**：这是所有按钮类的基类，提供了按钮的基本功能，如点击事件和状态管理。 2. **QAbstractFileEngine**：该类提供了访问文件系统的通用接口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值