redis学习笔记(五): serverCron

serverCron是redis里主要的定时处理函数，在initServer中通过调用aeCreateTimeEvent，将serverCron做为callback注册到全局的eventLoop结构当中。它在主循环中的位置：

aeMain
{
    while (!stop)
    {
        beforeSleep
        aeApiPoll
        process file events
        /* process time events */
        for each timeEntry(te) in eventLoop
        {
            retval = te->timeProc()    /* 这里面timeProc就是serverCron */
            if (NOMORE == retval)
                Delete time entry from eventLoop
            else
                aeAddMillisecondsToNow(te, retval) /* te下一次触发的时隔更新为retval */
        }
    }
}

看serverCron的实现之前先看这个run_with_period的定义:

#define run_with_period(_ms_) 
　　if ((_ms_ <= 1000/server.hz) || !(server.cronloops%((_ms_)/(1000/server.hz))))

由它的定义，run_with_period(_ms_)会在两种情况下返回1：

1. _ms_ <= 1000/server.hz，就是说_ms_比serverCron的执行间隔要小。

2. 或者_ms_比serverCron的执行间隔要大并且serverCron执行的次数刚好是_ms_/(1000/server.hz)的整数倍。

server.hz的意义是serverCron在一秒内执行的次数(从redis的实现来看，这个值是以ms为最小单位来计算的)，那么1000/server.hz就是serverCron的执行间隔(ms)，再结合run_with_period的定义可以看出，run_with_period表示每_ms_毫秒执行一段任务。

举个例子来说，server.hz是100，也就是servreCron的执行间隔是10ms(可能不完全精确，毕竟是单线程顺序执行)。

假如有一些任务需要每500ms执行一次，就可以在serverCron中用run_with_period(500)把每500ms需要执行一次的工作控制起来。所以，serverCron每执行到第500/10次，run_with_period(500)就会返回1

serverCron的实现如下：

int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    int j;
    REDIS_NOTUSED(eventLoop);
    REDIS_NOTUSED(id);
    REDIS_NOTUSED(clientData);

    /* Software watchdog: deliver the SIGALRM that will reach the signal
     * handler if we don't return here fast enough. */
    /* 用SIGALRM信号触发watchdog的处理过程，具体的函数为watchdogSignalHandler */
    if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);

    /* Update the time cache. */
    /* 更新server.unixtime和server.mstime */
    updateCachedTime();

    /* 每100ms更新一次统计量，包括这段时间内的commands, net_input_bytes, net_output_bytes */
    run_with_period(100) {
        trackInstantaneousMetric(REDIS_METRIC_COMMAND,server.stat_numcommands);
        trackInstantaneousMetric(REDIS_METRIC_NET_INPUT,
                server.stat_net_input_bytes);
        trackInstantaneousMetric(REDIS_METRIC_NET_OUTPUT,
                server.stat_net_output_bytes);
    }

    /* We have just REDIS_LRU_BITS bits per object for LRU information.
     * So we use an (eventually wrapping) LRU clock.
     *
     * Note that even if the counter wraps it's not a big problem,
     * everything will still work but some object will appear younger
     * to Redis. However for this to happen a given object should never be
     * touched for all the time needed to the counter to wrap, which is
     * not likely.
     *
     * Note that you can change the resolution altering the
     * REDIS_LRU_CLOCK_RESOLUTION define. */
     /* 根据server.lruclock的定义，getLRUClock返回的是当前时间换算成秒数的低23位 */
    server.lruclock = getLRUClock();

    /* Record the max memory used since the server was started. */
    /* 记录最大内存使用情况 */
    if (zmalloc_used_memory() > server.stat_peak_memory)
        server.stat_peak_memory = zmalloc_used_memory();

    /* Sample the RSS here since this is a relatively slow call. */
    /* 记录当前的RSS值 */
    server.resident_set_size = zmalloc_get_rss();

    /* We received a SIGTERM, shutting down here in a safe way, as it is
     * not ok doing so inside the signal handler. */
    /* 如果收到了SIGTERM信号，尝试退出 */
    if (server.shutdown_asap) {
        if (prepareForShutdown(0) == REDIS_OK) exit(0);
        redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
        server.shutdown_asap = 0;
    }

    /* Show some info about non-empty databases */
    /* 每5秒输出一次非空databases的信息到log当中 */
    run_with_period(5000) {
        for (j = 0; j < server.dbnum; j++) {
            long long size, used, vkeys;

            size = dictSlots(server.db[j].dict);
            used = dictSize(server.db[j].dict);
            vkeys = dictSize(server.db[j].expires);
            if (used || vkeys) {
                redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
                /* dictPrintStats(server.dict); */
            }
        }
    }

    /* Show information about connected clients */
    /* 如果不是sentinel模式，则每5秒输出一个connected的client的信息到log */
    if (!server.sentinel_mode) {
        run_with_period(5000) {
            redisLog(REDIS_VERBOSE,
                "%lu clients connected (%lu slaves), %zu bytes in use",
                listLength(server.clients)-listLength(server.slaves),
                listLength(server.slaves),
                zmalloc_used_memory());
        }
    }

    /* We need to do a few operations on clients asynchronously. */
    /* 清理空闲的客户端或者释放query buffer中未被使用的空间 */
    clientsCron();

    /* Handle background operations on Redis databases. */
    /* databases的处理，rehash就在这里 */
    databasesCron();

    /* Start a scheduled AOF rewrite if this was requested by the user while
     * a BGSAVE was in progress. */
    /* 如果开启了aof_rewrite的调度并且当前没有在background执行rdb/aof的操作，则进行background的aof操作 */
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 &&
        server.aof_rewrite_scheduled)
    {
        rewriteAppendOnlyFileBackground();
    }

    /* Check if a background saving or AOF rewrite in progress terminated. */    
    if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
        /* 如果有aof或者rdb在后台进行，则等待对应的退出。注意，这里用了WNOHANG，所以不会阻塞在wait3 */
        int statloc;
        pid_t pid;

        /* wait3返回非0值，要么是子进程退出，要么是出错 */
        if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
            int exitcode = WEXITSTATUS(statloc);
            int bysignal = 0;

            if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);

            /* 如果是出错，在log中记录这次错误
             * 如果是rdb任务退出，调用backgroundSaveDoneHandler进行收尾工作
             * 如果是aof任务退出，调用backgroundRewriteDoneHandler进行收尾工作
             */
            if (pid == -1) {
                redisLog(LOG_WARNING,"wait3() returned an error: %s. "
                    "rdb_child_pid = %d, aof_child_pid = %d",
                    strerror(errno),
                    (int) server.rdb_child_pid,
                    (int) server.aof_child_pid);
            } else if (pid == server.rdb_child_pid) {
                backgroundSaveDoneHandler(exitcode,bysignal);
            } else if (pid == server.aof_child_pid) {
                backgroundRewriteDoneHandler(exitcode,bysignal);
            } else {
                redisLog(REDIS_WARNING,
                    "Warning, detected child with unmatched pid: %ld",
                    (long)pid);
            }
            /* 如果当前有rdb/aof任务在处理，则将dict_can_resize设置为0(表示不允许进行resize)，否则，设置为1 */
            updateDictResizePolicy();
        }
    } else {
        /* 当前没有rdb/aof任务在执行，这里来判断是否要开启新的rdb/aof任务 */
        /* If there is not a background saving/rewrite in progress check if
         * we have to save/rewrite now */
         for (j = 0; j < server.saveparamslen; j++) {
            struct saveparam *sp = server.saveparams+j;

            /* Save if we reached the given amount of changes,
             * the given amount of seconds, and if the latest bgsave was
             * successful or if, in case of an error, at least
             * REDIS_BGSAVE_RETRY_DELAY seconds already elapsed. */
            if (server.dirty >= sp->changes &&
                server.unixtime-server.lastsave > sp->seconds &&
                (server.unixtime-server.lastbgsave_try >
                 REDIS_BGSAVE_RETRY_DELAY ||
                 server.lastbgsave_status == REDIS_OK))
            {
                redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
                    sp->changes, (int)sp->seconds);
                rdbSaveBackground(server.rdb_filename);
                break;
            }
         }

         /* Trigger an AOF rewrite if needed */
         if (server.rdb_child_pid == -1 &&
             server.aof_child_pid == -1 &&
             server.aof_rewrite_perc &&
             server.aof_current_size > server.aof_rewrite_min_size)
         {
            long long base = server.aof_rewrite_base_size ?
                            server.aof_rewrite_base_size : 1;
            long long growth = (server.aof_current_size*100/base) - 100;
            if (growth >= server.aof_rewrite_perc) {
                redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
                rewriteAppendOnlyFileBackground();
            }
         }
    }


    /* AOF postponed flush: Try at every cron cycle if the slow fsync
     * completed. */
    /* 如果开启了aof_flush_postponed_start，则在每次serverCron流程里都将server.aof_buf写入磁盘文件。
     * PS, server.aof_buf是从上一次写aof文件到目前为止所执行过的命令集合，所以是append only file
     */
    if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);

    /* AOF write errors: in this case we have a buffer to flush as well and
     * clear the AOF error in case of success to make the DB writable again,
     * however to try every second is enough in case of 'hz' is set to
     * an higher frequency. */
    /* 每一秒检查一次上一轮aof的写入是否发生了错误，如果有错误则尝试重新写一次 */
    run_with_period(1000) {
        if (server.aof_last_write_status == REDIS_ERR)
            flushAppendOnlyFile(0);
    }

    /* Close clients that need to be closed asynchronous */
    /* server.clients_to_close链表上的元素都是待关闭的连接 */
    freeClientsInAsyncFreeQueue();

    /* Clear the paused clients flag if needed. */
    /* clients被paused时，会相应地记录一个超时的时间，如果那个时间已经到来，则给client打上REDIS_UNBLOCKED标记(slave的client不处理)，并加到server.unblocked_clients上 */
    clientsArePaused(); /* Don't check return value, just use the side effect. */

    /* Replication cron function -- used to reconnect to master and
     * to detect transfer failures. */
    /* 每1秒执行一次replication */
    run_with_period(1000) replicationCron();

    /* Run the Redis Cluster cron. */
    /* 每100ms执行一次clusterCron */
    run_with_period(100) {
        if (server.cluster_enabled) clusterCron();
    }

    /* Run the Sentinel timer if we are in sentinel mode. */
    /* 每100ms执行一次sentine的定时器 */
    run_with_period(100) {
        if (server.sentinel_mode) sentinelTimer();
    }

    /* Cleanup expired MIGRATE cached sockets. */
    /* 每1秒清理一次server.migrate_cached_sockets链表上的超时sockets */
    run_with_period(1000) {
        migrateCloseTimedoutSockets();
    }

    /* serverCron执行次数 */
    server.cronloops++;
    /* 返回下一次执行serverCron的间隔 */
    return 1000/server.hz;
}