本篇内容，函数的单调性、对称性、奇偶性、周期性。
 
单调性
 
设区间D
 单调递增： 对任意的x1，x2∈D，当x1<x2恒有f(x1)<f(x2)
 单调递减： 对任意的x1，x2∈D，当x1<x2恒有f(x1)>f(x2)
 
对称性
 
轴对称
 

 f(x)关于x=xa轴对称的含义：若(x1+x2)/2=xa (xa为常数)，则f(x1)=f(x2)
 
比如f(1+x)=f(-2-x)，(1+x)+(-2-x)=-1,所以f(x)关于x=-(1/2)对称
 
中心对称
 
 
f(x)关于(a,b )中心对称的含义：若(x1+x2)/2=a ，则[f(x1)+f(x2)]/2=b
 
奇偶性
 
奇函数
 
奇函数的性质
 
定义域关于原点对称
f(x)+f(-x)=0 <=> f(-x)=-f(x)
关于(0,0)对称
奇函数f(0)不一定存在，如果f(0)存在，f(0)=0
 
偶函数
 
偶函数的性质
 
定义域关于原点对称
f(-x)-f(x)=0 <=> f(-x)=f(x)
关于x=0对称
 
敲黑板：只有奇次幂的函数是奇函数，只有偶次幂的函数是偶函数，任意函数都可以拆分为一个奇函数和一个偶函数的和
 证明：
 例题
 证明f(x)=x+x2为一个奇函数和一个偶函数之和
 
 不仅非奇非偶函数可以拆分为一个奇函数和一个偶函数之和，奇函数（或偶函数）也可以如此拆分，结果一部分为奇函数（或偶函数）另一部分为0
 
周期性
 
f(x)以T为周期的性质
 
f(x+T)=f(x)
f(x-T)=f(x)
T为周期，2T、3T…nT都是周期
 
周期性的数学描述
 若x1-x2=T，则f(x1)=f(x2)<=>以T为周期
 
f(x)以t为反周期的性质
 emmm“反周期”这个名字引用了永乐大帝的自制概念，实际上是没有这个东西的，具体是什么东西往下看吧。
 
f(x+t)=-f(x)
f(x-t)=-f(x)
T=2t
 到这应该知道t是个什么了，爱怎么叫都行，我就叫他反周期（有时候也叫小周期 doge）
 反周期的数学描述
 若x1-x2=t，则f(x1)=-f(x2)<=>以t为反周期
 
小结
 
辨识下列函数分别代表什么性质？
 ①f(1+x)+f(1-x)=0
 ②f(1+x)-f(1-x)=0
 ③f(x+1)+f(x-1)=0
 ④f(x+1)-f(x-1)=0
 
解析：
 ①(1+x)+(1-x)=2,对称性，f(1+x)+f(1-x)=0,和为常数，点对称，f(x)关于(1,0)点对称
 ②(1+x)+(1-x)=2,对称性，f(1+x)-f(1-x)=0，差为常数，或f(1+x)=f(1-x)，函数值相等，轴对称，f(x)关于x=1轴对称
 ③(x+1)-(x-1)=2,周期性，f(x+1)=-f(x-1)，反周期t=2，周期T=4
 ④(x+1)-(x-1)=2,周期性，f(x+1)=f(x-1)，周期T=2
 敲黑板 干货来了
 对称、周期、奇偶之间的关系，上图
 
 我把这个图叫三角关系图，还是两个三角关系，图中共有6个关系,刺不刺激？好了上解释。
 以左边为例，如果已知一个函数为奇函数，反周期为2a，则其对称轴为x=a；如果已知一个函数为奇函数，对称轴为x=a，则反周期为2a；如果一个函数有对称轴x=a，反周期为2a可得次函数为奇函数。
 
举其中一个关系的例子证明，已知函数f(x)为偶函数，且f(x)关于x=a轴对称，证明T=2a
 ∵f(x)关于x=a对称
 ∴f(x)=f(2a-x)
 ∵f(x)为偶函数
 ∴f(2a-x)=f(x-2a)
 得 f(x)=f(x-2a)
 
总结
 
本篇内容为函数的对称性、奇偶性和周期性，先说奇偶性，后面两个对照理解
 
奇偶性：首先无论奇偶，定义域关于原点对称，偶函数有f(x)-f(-x)=0，奇函数有f(x)+f(-x)=0，奇函数还有一条，不一定在x=0处有定义，比如反比例函数f(x)=1/x就是奇函数，但在x=0处没有定义，但是如果奇函数f(x)在x=0处有定义，则f(0)=0
对称性和周期性：判断对称性和周期性，首先看自变量的关系，然后看函数值的关系。若自变量和为常数即为对称性，函数值和为常数——点对称；函数值相等——轴对称。若自变量差为常数，即为周期性，函数值相等为周期，函数值相反为反周期。

 
 
 
 
 
 1.启动Activity：系统会先调用onCreate方法，这是生命周期第一个方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。
 
 onCreate方法：一般做一些初始化工作，比如setContentView去加载布局资源，初始化Activity所需的数据。
 
 
 onStart方法：表示Activity正在启动，已经可见，但是无法和用户交互。
 
 onResume方法：Activity已经可见并且开始活动，已经出现在前台。
 
 
 
 
 
 2.当前Activity被其他Activity覆盖其上或被锁屏：
 
 （可以理解为没有完全遮挡界面的）
 
 系统会调用onPause方法，暂停当前Activity的执行。
 
 3.当前Activity由被覆盖状态回到前台或解锁屏：
 
 系统会调用onResume方法，再次进入运行状态。
 
 4.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：
 
 系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。
 
 5.用户后退回到此Activity：
 
 系统会先调用onRestart方法，
 
 然后调用onStart方法，
 
 最后调用onResume方法，
 
 再次进入运行状态。
 
 6.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。
 
 但是知道这些还不够，我们必须亲自试验一下才能深刻体会，融会贯通。
 
 
 
 
 Activity四种启动模式的区别：standard    singleTop  singleTask   singleInstance
 
 
 
 
 standard：每次激活Activity时(startActivity)，都创建Activity实例，并放入任务栈； 
 
 
 
 
 singleTop：如果某个Activity自己激活自己并且Activity处于栈顶，则不需要创 建，其余情况都要创建Activity实例；
 
  
 
 singleTask：如果要激活的那个Activity在任务栈中存在该实例，则不需要创建，只需要把 此Activity放入栈顶，即把该Activity以上的Activity实例都pop，并调用其onNewIntent；
 
  
 
 singleInstance：应用1的任务栈中创建了MainActivity实例，如果应用2也要激活 MainActivity，则不需要创建，两应用共享该Activity实例。
 
 
 
 onSaveInstanceState的调用遵循一个重要原则，即当系统“未经你许可”时销毁了你的 activity，则onSaveInstanceState会被系统调用，这是系统的责任，因为它必须要提供一 个机会让你保存的数据。
 
 至于onRestoreInstanceState方法，需要注意的是， onSaveInstanceState方法和onRestoreInstanceState方法“不一定”是成对的被调用 的。 
 
 
 
 
 onRestoreInstanceState被调用的前提是，activity A“确实”被系统销毁了，而如果仅仅 是停留在有这种可能性的情况下，则该方法不会被调用，例如，当正在显示activity A的时 候，用户按下HOME键回到主界面，然后用户紧接着又返回到activity A，这种情况下 activity A一般不会因为内存的原因被系统销毁
 
 故activity A的onRestoreInstanceState方 法不会被执行。
 
 
 
 
  另外，onRestoreInstanceState的bundle参数也会传递到onCreate方法中，你也可以选择 在onCreate方法中做数据还原。
 
 
 
 
 切换横竖屏的生命周期：
 
 
 
 
 1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，
 切横屏时会执行一次，切竖屏时会执行两次
 
 2、设置Activity的android:configChanges="orientation"时，切屏还是会重新调
 用各个生命周期，切横、竖屏时只会执行一次
 
 3、设置Activity的android:configChanges="orientation|keyboardHidden"时，
 切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法
 
 
 
 
 
 Activity运行时按下HOME键(跟被完全覆盖是一样的)：
 
 onSaveInstanceState -->onPause --> onStop  --> onRestart-->onStart--->onResume
 
 Activity未被完全覆盖只是失去焦点：onPause--->onResume

引言
 
在做Android App开发的过程相信大家都会遇到周期性执行一些任务的需求，比如说每隔一段时间刷新下界面，每隔一段时间刷新下当前的天气情况或者实现类似Windows的若干时间自动播放屏保等等。
 
一、概述
 
任务调度是指基于给定时间点，给定时间间隔或者给定执行次数自动执行任务，简而言之可以理解成周期性执行某一项任务。
 
二、任务调度的实现方式
 
通常任务调度机制实现的方式主要有以下几种：Timer、ScheduledExecutor、Handler和其他第三方开源库
 
1、Timer
 
java.util.Timer是Java语言本身提供的一种最简单实现任务调度的方法，使用起来也很简单，通过对应的api调用即可。Timer 的设计核心是一个 TaskQueue和一个 TaskThread。Timer 将接收到的任务丢到自己的 TaskQueue中，TaskQueue按照 Task 的最初执行时间进行排序。TimerThread 在创建 Timer 时会启动成为一个守护线程，这个守护线程会轮询所有任务，找到一个最近要执行的任务，然后休眠，当到达最近要执行任务的开始时间点，TimerThread 被唤醒并执行该任务。之后 TimerThread 更新最近一个要执行的任务，继续休眠。
 
继承TimerTask实现具体的作业任务类
重写run方法实现具体的作业操作
构造Timer对象并调用schedule方法传入指定参数即可
 
public class PeriodicOperations {

        public static void main(String[] args) {
        testTimerWay();
    }

    private static void testTimerWay(){
        Timer timer = new Timer(); 
        long delay1 = 1 * 1000; 
        long period1 = 1000; 
        // 从现在开始 1 秒钟之后，每隔 1 秒钟执行一次 job1 
        timer.schedule(new TimerTest("job1"), delay1, period1); 
        long delay2 = 2 * 1000; 
        long period2 = 2000; 
        // 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2 
        timer.schedule(new TimerTest("job2"), delay2, period2); 
    }

    static class TimerTest extends TimerTask{
        private String jobName = ""; 
        public TimerTest(String job) {
            super();
            this.jobName=job;
        }
        @Override
        public void run() {
            System.out.println("执行作业："+jobName);
        }
    }
}
 
 
Timer机制实现任务调度的核心类是 Timer 和 TimerTask。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。使用者只需要创建一个 TimerTask 的继承类，实现自己的 run 方法，然后将其丢给 Timer 去执行即可。Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务，所以不太适合并发类的任务调度。
 
2、ScheduledExecutor
 
为了弥补Timer 的上述缺陷，在Java 5的时候推出了基于线程池设计的 ScheduledExecutor。其设计思想是：每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。但需要注意的是只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。
 
定义一个作业线程负责实现具体的操作逻辑
创建一个线程池用于管理作业线程
调用线程池的对应方法（ScheduleWithFixedDelay或ScheduleAtFixedRate ）启动周期性机制
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class PeriodicOperations {

    public static void main(String[] args) {
        testScheduledExecutorWay();
    }

    private static void testScheduledExecutorWay(){
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);//创建线程池的方式有几种，可以根据业务具体选择

        long initialDelay1 = 1;
        long period1 = 1;
        // 从现在开始1秒钟之后，每隔1秒钟执行一次job1
        service.scheduleAtFixedRate(
                new ScheduledExecutorTest("job1"), initialDelay1,
                period1, TimeUnit.SECONDS);

        long initialDelay2 = 1;
        long delay2 = 1;
        // 从现在开始2秒钟之后，每隔2秒钟执行一次job2
        service.scheduleWithFixedDelay(
                new ScheduledExecutorTest("job2"), initialDelay2,
                delay2, TimeUnit.SECONDS);
    }

    static class ScheduledExecutorTest implements Runnable{
        private String jobName = "";

        public ScheduledExecutorTest(String jobName) {
            super();
            this.jobName = jobName;
        }

        @Override
        public void run() {
            System.out.println(getNowTime()+"执行作业：" + jobName);
        }
    }

    public static String getNowTime(){
        Date now = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");// 可以方便地修改日期格式
        return dateFormat.format(now);
    }
}
 
ScheduledExecutorService 中两种最常用的调度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。其中ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；而ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。所以两种方式异同在于ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度。 
 
 
3、结合 ScheduledExecutor 和 Calendar 实现复杂任务调度
 
无论是Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能实现更加复杂的调度需求。比如说设置每星期二的 16:38:10 执行任务等等，单独使用 Timer 或 ScheduledExecutor 都不能直接实现，但我们可以借助 Calendar 间接实现该功能。
 
import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExceutorTest2 extends TimerTask {

    private String jobName = "";

    public ScheduledExceutorTest2(String jobName) {
        super();
        this.jobName = jobName;
    }

    @Override
    public void run() {
        System.out.println("Date = "+new Date()+", execute " + jobName);
    }

    /**
     * 计算从当前时间currentDate开始，满足条件dayOfWeek, hourOfDay, 
     * minuteOfHour, secondOfMinite的最近时间
     * @return
     */
    public Calendar getEarliestDate(Calendar currentDate, int dayOfWeek,
            int hourOfDay, int minuteOfHour, int secondOfMinite) {
        //计算当前时间的WEEK_OF_YEAR,DAY_OF_WEEK, HOUR_OF_DAY, MINUTE,SECOND等各个字段值
        int currentWeekOfYear = currentDate.get(Calendar.WEEK_OF_YEAR);
        int currentDayOfWeek = currentDate.get(Calendar.DAY_OF_WEEK);
        int currentHour = currentDate.get(Calendar.HOUR_OF_DAY);
        int currentMinute = currentDate.get(Calendar.MINUTE);
        int currentSecond = currentDate.get(Calendar.SECOND);

        //如果输入条件中的dayOfWeek小于当前日期的dayOfWeek,则WEEK_OF_YEAR需要推迟一周
        boolean weekLater = false;
        if (dayOfWeek < currentDayOfWeek) {
            weekLater = true;
        } else if (dayOfWeek == currentDayOfWeek) {
            //当输入条件与当前日期的dayOfWeek相等时，如果输入条件中的
            //hourOfDay小于当前日期的
            //currentHour，则WEEK_OF_YEAR需要推迟一周   
            if (hourOfDay < currentHour) {
                weekLater = true;
            } else if (hourOfDay == currentHour) {
                 //当输入条件与当前日期的dayOfWeek, hourOfDay相等时，
                 //如果输入条件中的minuteOfHour小于当前日期的
                //currentMinute，则WEEK_OF_YEAR需要推迟一周
                if (minuteOfHour < currentMinute) {
                    weekLater = true;
                } else if (minuteOfHour == currentSecond) {
                     //当输入条件与当前日期的dayOfWeek, hourOfDay， 
                     //minuteOfHour相等时，如果输入条件中的
                    //secondOfMinite小于当前日期的currentSecond，
                    //则WEEK_OF_YEAR需要推迟一周
                    if (secondOfMinite < currentSecond) {
                        weekLater = true;
                    }
                }
            }
        }
        if (weekLater) {
            //设置当前日期中的WEEK_OF_YEAR为当前周推迟一周
            currentDate.set(Calendar.WEEK_OF_YEAR, currentWeekOfYear + 1);
        }
        // 设置当前日期中的DAY_OF_WEEK,HOUR_OF_DAY,MINUTE,SECOND为输入条件中的值。
        currentDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        currentDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
        currentDate.set(Calendar.MINUTE, minuteOfHour);
        currentDate.set(Calendar.SECOND, secondOfMinite);
        return currentDate;

    }

    public static void main(String[] args) throws Exception {

        ScheduledExceutorTest2 test = new ScheduledExceutorTest2("job1");
        //获取当前时间
        Calendar currentDate = Calendar.getInstance();
        long currentDateLong = currentDate.getTime().getTime();
        System.out.println("Current Date = " + currentDate.getTime().toString());
        //计算满足条件的最近一次执行时间
        Calendar earliestDate = test
                .getEarliestDate(currentDate, 3, 16, 38, 10);
        long earliestDateLong = earliestDate.getTime().getTime();
        System.out.println("Earliest Date = "
                + earliestDate.getTime().toString());
        //计算从当前时间到最近一次执行时间的时间间隔
        long delay = earliestDateLong - currentDateLong;
        //计算执行周期为一星期
        long period = 7 * 24 * 60 * 60 * 1000;
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        //从现在开始delay毫秒之后，每隔一星期执行一次job1
        service.scheduleAtFixedRate(test, delay, period,
                TimeUnit.MILLISECONDS);

    }
}
 
其核心在于根据当前时间推算出最近一个星期二 16:38:10 的绝对时间，然后计算与当前时间的时间差，作为调用 ScheduledExceutor 函数的参数。计算最近时间要用到 java.util.calendar 的功能。首先需要解释 Calendar 的一些设计思想。Calendar 有以下几种唯一标识一个日期的组合方式：
 
YEAR + MONTH + DAY_OF_MONTH 
YEAR + MONTH + WEEK_OF_MONTH +
YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK 
YEAR+ DAY_OF_YEAR YEAR + DAY_OF_WEEK + WEEK_OF_YEAR
 
上述组合分别加上 HOUR_OF_DAY + MINUTE + SECOND 即为一个完整的时间标识。本例采用了最后一种组合方式。输入为 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 以及当前日期 , 输出为一个满足 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 并且距离当前日期最近的未来日期。计算的原则是从输入的 DAY_OF_WEEK 开始比较，如果小于当前日期的 DAY_OF_WEEK，则需要向 WEEK_OF_YEAR 进一， 即将当前日期中的 WEEK_OF_YEAR 加一并覆盖旧值；如果等于当前的 DAY_OF_WEEK, 则继续比较 HOUR_OF_DAY；如果大于当前的 DAY_OF_WEEK，则直接调用 java.util.calenda 的 calendar.set(field, value) 函数将当前日期的 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 赋值为输入值，依次类推，直到比较至 SECOND。也可以根据输入需求选择不同的组合方式来计算最近执行时间。
 
4、Handler机制
 
以上三种方式都是由Java语言提供的机制，其实Android 本身也提供了自己的机制，只不过需要我们灵活去应用，尤其是涉及到界面操作的周期性需要灵活控制的任务调度，Handler机制应该算是比较合适一种方式，结合其他机制可以无缝地操作界面。我以实现仿Windows 屏保机制来说明，简单说下需求，当设备在若干分钟无人进行交互的时候，自动播放屏保，这也可以看成一个灵活的任务调度，因为当到达指定时间之前，有人交互，此时又得重新计算起点，而不是固定的在一个时间间隔内一定会触发。
 
public abstract class BaseActivity extends AppCompatActivity {
    public static final int MSG_WELCOME = 11;
    private final static long DELAY=10*60*1000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityManager.addActivity(this);
        setFullScreen();
    }

    @Override
    protected void onResume() {
        super.onResume();
        startTask();//首先在onResume 中开启任务调度，此时相当于开始倒计时，如果没被打断将会在DELAY 时间间隔之后执行预订的弹出屏保
    }

    @Override
    protected void onStop() {
        super.onStop();
        stopTask();//停止任务调度
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

    private void setFullScreen(){
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        stopTask();//当有人在交互的时候就中断当前的任务调度，重新开启
        startTask();
        return super.dispatchTouchEvent(ev);
    }

    private ObverHandler takePhotoHandler =new ObverHandler(this);


    protected void handleMsg(int what){
        if(what== MSG_WELCOME) {
            ScreenActivity.showScreenActivity(this);//当接收到Message 时，跳到屏保界面
            return;
        }
        return;
    }

    protected boolean isTopActivity(String activity) {
        android.app.ActivityManager am = (android.app.ActivityManager) getSystemService(ACTIVITY_SERVICE);
        ComponentName cn = am.getRunningTasks(1).get(0).topActivity;
        return cn.getClassName().contains(activity);
    }

    /**
    *开启周期性任务调度
    */
    protected void startTask(){
        if(takePhotoHandler !=null) {
            if(isTopActivity("ScreenActivity")){
                return;
            }else{
                takePhotoHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        takePhotoHandler.sendMsg(MSG_WELCOME);
                    }
                }, DELAY);
            }
        }
    }

    /**
    *停止周期性任务调度，假如在还未到所指定的时间任务呗手动停止了，比如说有人交互了，此时需要重新计算任务开始的起点，所以需要在业务逻辑中手动去重新开启任务调度
    */
    private void stopTask(){
        if (takePhotoHandler !=null){
            LogUtil.showErroLog("STOP TASK WELCOMEActivity");
            takePhotoHandler.removeCallbacksAndMessages(null);//就是把未处理的Meesgae 全部清空
        }
    }

    static class ObverHandler extends Handler {
        private final WeakReference<BaseActivity> mAct;//声明弱引用
        //声明构造方法供外部调用构ObverHandler对象
        public ObverHandler(BaseActivity act){
            mAct=new WeakReference<>(act);
        }
        public void handleMessage(Message msg){

            mAct.get().handleMsg(msg.what);
        }
        public void sendMsg(int what){
            sendEmptyMessage(what);
        }
    }
}
 
以上屏保案例实质上借助了Handler的postDelayed方法和removeCallbacksAndMessages灵活实现的一种所谓的周期性任务调度，当然也可以借助其他机制来实现开启和停止，一切取决于你的需求。
 
5、第三方开源库
 
上述方法实现该任务调度比较麻烦，这就需要一个更加完善的任务调度框架来解决这些复杂的调度问题。幸运的是，开源工具包 Quartz 与 JCronTab 提供了这方面强大的支持（使用攻略参见IBM开发社区。）
 
小结
 
对于简单的基于起始时间点与时间间隔的任务调度，使用 Timer 就足够了；如果需要同时调度多个任务，基于线程池的 ScheduledTimer 是更为合适的选择；当任务调度的策略复杂到难以凭借起始时间点与时间间隔来描述时，Quartz 与 JCronTab 则体现出它们的优势。熟悉 Unix/Linux 的开发人员更倾向于 JCronTab，且 JCronTab 更适合与 Web 应用服务器相结合。Quartz 的 Trigger 与 Job 松耦合设计使其更适用于 Job 与 Trigger 的多对多应用场景。

日期
内核版本
架构
作者
内容
2019-5-13
Linux-2.6.32
 
X86
 
Bystander
Linux进程调度
1 绪论
 
在《Linux系统进程调度——调度架构详细分析》一文已经讲解Linux内核中实现了两个调度器：主调度器和周期调度器，两者合称为通用调度器或核心调度器，也详细解释调度框架、调度类、调度实体、调度策略等内容。
 
在《Linux系统进程核心调度器——主调度器schedule函数详解》一文中说明由以下两种方式分别触发激活主调度器和周期调度器：
 
进程直接放弃CPU
通过周期性机制, 以固定的频率检测是否有必要调度
2 周期调度器
 
周期性调度器在scheduler_tick()中实现。 如果系统正在活动中， 内核会按照频率HZ自动调用该函数。 如果没有进程在等待调度，在计算机电力供应不足的情况下， 内核将关闭该调度器以减少能耗。
 
2.1 如何调用scheduler_tick()
 
在单处理系统上的全局时钟 中断处理程序或者多处理器系统上的本地时钟中断处理程序将调用update_process_times()来更新内核统计计数。update_process_times()主要完成以下任务：
 
首先调用account_process_tick（），它根据当前进程运行了多久时间和当前进程类别，选择调用account_user_time()、account_system_time()，还是account_idle_time()。
调用run_local_timers()，从而间接调用raise_softirq()，用来激活本地CPU上的TIMER_SOFTIRQ任务队列。
调用scheduler_tick()，该函数使当前进程时间片计数器减1，并检查计数器是否已经减到0。
void update_process_times(int user_tick)
{
	struct task_struct *p = current;
	int cpu = smp_processor_id();

	/* Note: this timer irq context must be accounted for as well. */
	account_process_tick(p, user_tick);
	run_local_timers();
	rcu_check_callbacks(cpu, user_tick);
	printk_tick();
	scheduler_tick();
	run_posix_cpu_timers(p);
}
 
2.2 scheduler_tick()实现
 
在scheduler_tick()中主要实现以下5个主要工作：
 
调用sched_clock_tick()以纳秒为单位将当前时间放入sched_clock_data中；
调用update_rq_clock()就绪队列时钟的更新, 实际上更新struct rq当前实例的时钟时间戳；
调用update_cpu_load()更新CPU上负载，为下一步执行调度类挑选进程做准备；
调用curr->sched_class->task_tick()内核先找到了就绪队列上当前运行的进程curr, 然后调用curr所属调度类sched_class的周期性调度方法task_tick。在Linux-2.6.32中有task_tick_rt(), task_tick_fair(), task_tick_idle()。
如果系统支持SMP则调用trigger_load_balance()定期进行堵负载均衡。
scheduler_tick()源码如下：
 
void scheduler_tick(void)
{
    /*获取当前CPU ID*/
	int cpu = smp_processor_id();
    /*根据CPU ID 获取当前CPU运行队列rq*/
	struct rq *rq = cpu_rq(cpu);
    /*获取当前CPU上运行队列正在运行进程*/
	struct task_struct *curr = rq->curr;
    /*以纳秒为单位将当前时间放入sched_clock_data中*/
	sched_clock_tick();

	spin_lock(&rq->lock);
    /*更新rq的时间.即使rq->clock变为当前时间*/  
	update_rq_clock(rq);
     /*更新负载信息，也就是更新rq->cpu_load[]*/  
	update_cpu_load(rq);
/*执行当前运行进程curr的调度类的task_tick函数*/
	curr->sched_class->task_tick(rq, curr, 0);
	spin_unlock(&rq->lock);
     /* 与perf计数事件相关 */
	perf_event_task_tick(curr, cpu);

#ifdef CONFIG_SMP
    /*判断当前CPU是否空闲*/
	rq->idle_at_tick = idle_cpu(cpu);
/* 如果需要定期进行负载平衡，则触发sched_softirq */
	trigger_load_balance(rq, cpu);
#endif
}