精华内容
下载资源
问答
  • 通过纳焦量级的飞秒激光在铬膜表面诱导出了周期性微结构,并使用入射飞秒激光和激发的表面等离子体波之间的干涉理论模拟分析了飞秒激光作用下铬膜表面的温度场分布情况,定性地解释了铬膜表面周期性微结构产生的机理。...
  • 在所有季节中,周期性活动都会在夜间引起正面风暴,而在白天则没有影响。 从这项研究中可以看出,该站风暴的积极影响可能是由热层成分的变化所解释的。 周期性活动更多发生在日照减少阶段和Spring月份。 风暴强度...
  • 函数的奇偶性、周期性和单调性

    千次阅读 2020-08-25 18:11:46
    本篇内容,函数的奇偶性、周期性、单调性。 对称性 轴对称 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)...

    本篇内容,函数的单调性、对称性、奇偶性、周期性。

    单调性

    设区间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

    奇偶性

    奇函数

    奇函数的性质

    1. 定义域关于原点对称
    2. f(x)+f(-x)=0 <=> f(-x)=-f(x)
    3. 关于(0,0)对称
    4. 奇函数f(0)不一定存在,如果f(0)存在,f(0)=0

    偶函数

    偶函数的性质

    1. 定义域关于原点对称
    2. f(-x)-f(x)=0 <=> f(-x)=f(x)
    3. 关于x=0对称

    敲黑板:只有奇次幂的函数是奇函数,只有偶次幂的函数是偶函数,任意函数都可以拆分为一个奇函数和一个偶函数的和
    证明:在这里插入图片描述
    例题
    证明f(x)=x+x2为一个奇函数和一个偶函数之和
    在这里插入图片描述
    不仅非奇非偶函数可以拆分为一个奇函数和一个偶函数之和,奇函数(或偶函数)也可以如此拆分,结果一部分为奇函数(或偶函数)另一部分为0

    周期性

    f(x)以T为周期的性质

    1. f(x+T)=f(x)
    2. f(x-T)=f(x)
    3. T为周期,2T、3T…nT都是周期

    周期性的数学描述
    若x1-x2=T,则f(x1)=f(x2)<=>以T为周期

    f(x)以t为反周期的性质
    emmm“反周期”这个名字引用了永乐大帝的自制概念,实际上是没有这个东西的,具体是什么东西往下看吧。

    1. f(x+t)=-f(x)
    2. f(x-t)=-f(x)
    3. 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
    • 对称性和周期性:判断对称性和周期性,首先看自变量的关系,然后看函数值的关系。若自变量和为常数即为对称性,函数值和为常数——点对称;函数值相等——轴对称。若自变量差为常数,即为周期性,函数值相等为周期,函数值相反为反周期。
    展开全文
  • Activity 生命周期详细解释

    千次阅读 2016-09-01 22:49:52
    1、不设置Activity的android:configChanges时,切屏会重新调用各个生命周期, 切横屏时会执行一次,切竖屏时会执行两次 2、设置Activity的android:configChanges="orientation"时,切屏还是会重新调 用各个生命周期...


    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

    展开全文
  • 从而得到理想的同步整流驱动波形,利用周期性变结构整形理论完整地解释了一种现有的电荷自维持电路,并且构造出了一系列新颖的周期性变结构整形电路,对一个36~75V输入,5V/10A输出,采用周期性变结构整形电路的...
  • 任务调度是指基于给定时间点,给定时间间隔或者给定执行次数自动执行任务,简而言之可以理解成周期性执行某一项任务。

    引言

    在做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 的多对多应用场景。

    展开全文
  • 列举了一系列实例,说明生物系统发育形态演变的周期性,讨论了形态演变周期性的实质。个体发育形态变化系列,有时与其后来的系统发育演化系列相似,...依据生物系统发育形态演化的周期性,可以解释个体发育的预演现象。
  • 在《Linux系统进程调度——调度架构详细分析》一文已经讲解Linux内核中实现了两个调度器:主调度器和周期调度器,两者合称为通用调度器或核心调度器,也详细解释调度框架、调度类、调度实体、...
    日期内核版本架构作者内容
    2019-5-13Linux-2.6.32

    X86

    BystanderLinux进程调度

    1 绪论

    《Linux系统进程调度——调度架构详细分析》一文已经讲解Linux内核中实现了两个调度器:主调度器周期调度器,两者合称为通用调度器核心调度器,也详细解释调度框架、调度类、调度实体、调度策略等内容。

    《Linux系统进程核心调度器——主调度器schedule函数详解》一文中说明由以下两种方式分别触发激活主调度器周期调度器:

    1. 进程直接放弃CPU
    2. 通过周期性机制, 以固定的频率检测是否有必要调度

    2 周期调度器

    周期性调度器在scheduler_tick()中实现。 如果系统正在活动中, 内核会按照频率HZ自动调用该函数。 如果没有进程在等待调度,在计算机电力供应不足的情况下, 内核将关闭该调度器以减少能耗。

    2.1 如何调用scheduler_tick()

    在单处理系统上的全局时钟 中断处理程序或者多处理器系统上的本地时钟中断处理程序将调用update_process_times()来更新内核统计计数。update_process_times()主要完成以下任务:

    1. 首先调用account_process_tick(),它根据当前进程运行了多久时间和当前进程类别,选择调用account_user_time()、account_system_time(),还是account_idle_time()。
    2. 调用run_local_timers(),从而间接调用raise_softirq(),用来激活本地CPU上的TIMER_SOFTIRQ任务队列。
    3. 调用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个主要工作:

    1. 调用sched_clock_tick()以纳秒为单位将当前时间放入sched_clock_data中;
    2. 调用update_rq_clock()就绪队列时钟的更新, 实际上更新struct rq当前实例的时钟时间戳;
    3. 调用update_cpu_load()更新CPU上负载,为下一步执行调度类挑选进程做准备;
    4. 调用curr->sched_class->task_tick()内核先找到了就绪队列上当前运行的进程curr, 然后调用curr所属调度类sched_class的周期性调度方法task_tick。在Linux-2.6.32中有task_tick_rt(), task_tick_fair(), task_tick_idle()。
    5. 如果系统支持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
    }
    

     

    展开全文
  • 本文基于自由空间的部分相干传递函数对效应提出了新的解释模型,给出了描述Lau条纹强度分布的普遍公式,它适用于任意周期性的振幅或位相型物体,对于几种典型周期性物体分析了Lau条纹产生的条件及输出强度.给出了不同...
  • 使用 FFT 分析周期性数据

    千次阅读 2019-02-22 23:00:00
    为了查看更易解释周期活动,以周期函数形式绘制幂图,以每周期的年数为测量单位。该绘图揭示了太阳黑子活动约每 11 年出现一次高峰。 period = 1./freq; plot(period,power); xlim([0 50]); %zoom in on ...
  • 离散正弦信号的周期性

    千次阅读 2013-04-26 13:46:00
    因为这两个频率的正弦波在512个取样点中正好有整数个周期。满足这个条件波形的FFT结果能够精确地反映其频谱。N点FFT能精确计算的频率 假设取样频率为fs, 取波形中的N个数据进行FFT变换。那么这N点数据包含整数个...
  • 通过Matlab 使用 FFT 分析周期性数据

    千次阅读 2018-10-14 20:51:56
    傅里叶变换可以用 来分析数据中的变化 前言 :天文学家使用苏黎世太阳...为了查看更易解释周期活动,以周期函数形式绘制幂图,以每周期的年数为测量单位。该绘图揭示了太阳黑子活动约每 11 年出现一次高峰。
  • Jeffrey:我不知道它是否真的坏到了这种程度,AI寒冬只是周期性的。作为计算机科学的一个分支,AI的意图是让计算机、机器人的举止行为像人一样,并且能够像人一样思考。AI社区有些独特,他们许下了各种各样奇妙的...
  • http://docs.unity3d.com/Manual/ExecutionOrder.html 生命周期Unity手册上的解析 注:图后附有常用函数的简单解释和详细解释 一、简单解释 (1) Reset() 组件重设为默认值时(只用于编辑状态) (2)...
  • Jeffrey:我不知道它是否真的坏到了这种程度,AI寒冬只是周期性的。作为计算机科学的一个分支,AI的意图是让计算机、机器人的举止行为像人一样,并且能够像人一样思考。AI社区有些独特,他们许下了各种各样奇妙的...
  •  但是从行业的角度来看,我们造价工作者不应该局限本专业的范围,我们在头脑应该有一个BIM宏观的概念,首先了解BIM在整个建筑生命周期都能做什么,其次是掌握造价行业的新软件新技术,头脑中一定要时刻建立一个模型...
  • 微软官方解释:Product:Windows Operating SystemEvent ID:101Source:ESENTVersion:5.2Symbolic Name:STOP_IDMessage:%1 (%2) %3The database engine stopped. Explanation The extensible storage ...
  • 以虚拟经济理论为指导, 运用复杂科学的方法, 从国际原油市场主体的多元化、 国际原油市场定价机制的演化、国际原油市场参与者结构的变化以及世界经济的周期性发展变化四个角度来解释国际原油实际价格对均衡价格的...
  • 研究了一类周期环境中既有比例收获又有常量收获的一维脉冲系统正周期解存在的条件以及解的一些基本性质;...该方法是构造的,以利于用数值方法求其周期解。给出一个实例并用数值模拟方法解释说明了所获得的主要结论
  • 周期延拓

    千次阅读 2019-07-29 15:41:11
    为什么离散采样后的信号傅里叶变换后,在频域上的图像是周期性的,即离散采样后的信号的频谱跟原始信号频谱相比,为什么发生了周期延拓。本文来试图去解释这个问题。 先来看一下时域抽样,本文假设抽样脉冲是冲击...
  • 什么是软件生命周期

    千次阅读 2017-03-03 16:20:35
    软件生命周期又称为软件生存周期或系统开发生命周期,是软件的产生直到报废的生命周期周期内有问题定义、可行分析、总体描述、系统设计、编码、调试和测试、验收与运行、维护升级到废弃等阶段,这种按时间分程的...
  • 当面试官问:“谈谈你对vue的生命周期的理解”,听到这句话你是不是心里暗自窃喜:这也太容易了吧,不就是beforeCreate、created、beforeMount、mounted、beforeUpdate、updated、beforeDestroy、destroyed 这几个...
  • 周期噪声

    千次阅读 2019-06-19 22:35:59
    标题
  • 博主声明: 转载请在开头附加本文链接及作者信息,并标记为转载。... 在学习 Android 时候,通常一开始学习的都是它的生命周期,谁让我们第一个创建的就是 MainActivity 类呢。学习 Activity 就要从它...
  • Spring 中Bean 的生命周期

    千次阅读 多人点赞 2019-05-11 10:09:12
    ​ 这其实是一道面试题,是我在面试百度的时候被问到的,当时没有答出来(因为自己真的很菜),后来在网上寻找答案,看到也是一头雾水,直到看到了《Spring in action》这本书,书上有对Bean声明周期的大致解释,但是...
  • Gradle基础:3:生命周期管理

    千次阅读 2018-11-20 05:53:03
    Maven中的生命周期的管理使用了COC,以此为中心的pom.xml文件成为了重中之重,优点是不同项目之间的经验共享变得更加容易,大家大部分都是可以使用类似的套路,缺点则是灵活稍微降低以及对于pom.xml细节的学习需要...
  • 频率和周期的关系

    万次阅读 2019-12-13 16:34:11
    通用解释为 -----频率,是单位时间内完成周期性变化的次数,是描述周期运动频繁程度的量,常用符号f或ν表示,单位为秒分之一,Hz是频率的基本单位,通常是以1秒完成的动作次数。比如你1秒能吃3个馒头那就记作你吃...
  • 重点研究了无切延迟操作时TD-ERCS系统的周期轨道分布和描述方法,揭示了系统圆对称退化导致周期轨道...通过建立一个对称退化的刚性模型,解释了过焦系统是TD-ERCS系统中的周期2对称退化的结果,并给出了几个短周期.
  • 一文读懂 Spring Bean 的生命周期

    千次阅读 多人点赞 2021-07-05 23:02:56
    今天我们来说一说 Spring Bean 的生命周期,小伙伴们应该在面试中经常遇到,这是正常现象。因为 Spring Bean 的生命周期是除了 IoC、AOP 几个核心概念之外最重要概念,大家务必拿下。可 Spring 源代码又比较复杂,...
  • React v16.3新生命周期浅谈

    万次阅读 2018-05-13 21:55:48
    在这次的更新中,除了前段时间被热烈讨论的新 Context API 之外,新引入的两个生命周期函数 getDerivedStateFromProps,getSnapshotBeforeUpdate 以及在未来 v17.0 版本中即将被移除的三个生命周期函数 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 222,500
精华内容 89,000
关键字:

周期性的解释是