当我们在启动redis的时候，我们在启动什么

#ifdef INIT_SETPROCTITLE_REPLACEMENT
    spt_init(argc, argv);
#endif

zmalloc_enable_thread_safeness();
zmalloc_set_oom_handler(redisOutOfMemoryHandler);

// 设置随机数种子
srand(time(NULL)^getpid());

// 设置哈希函数种子
struct timeval tv;
gettimeofday(&tv,NULL);
dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());

void initServerConfig() {
    // 服务器状态设置
    server.hz = REDIS_DEFAULT_HZ;
    server.port = REDIS_SERVERPORT;
    server.tcp_backlog = REDIS_TCP_BACKLOG;
    
    // 数据库配置
    server.dbnum = REDIS_DEFAULT_DBNUM;
    
    // 持久化相关配置  
    server.aof_state = REDIS_AOF_OFF;
    server.rdb_compression = REDIS_DEFAULT_RDB_COMPRESSION;
    
    // 创建命令表
    server.commands = dictCreate(&commandTableDictType,NULL);
    populateCommandTable();
    
    // 其他重要配置...
}

server.clients = listCreate();  // 客户端列表
server.slaves = listCreate();   // 从服务器列表
server.monitors = listCreate(); // 监视器列表

// TCP监听
if (server.port != 0) {
    listenToPort(server.port,server.ipfd,&server.ipfd_count);
}

// Unix域套接字
if (server.unixsocket != NULL) {
    unlink(server.unixsocket);
    server.sofd = anetUnixServer(/*...*/);
}

void bioInit(void) {
    // 线程1: 处理文件关闭
    pthread_create(&thread, &attr, bioProcessBackgroundJobs,
        (void*)REDIS_BIO_CLOSE_FILE);
        
    // 线程2: 处理AOF同步
    pthread_create(&thread, &attr, bioProcessBackgroundJobs,
        (void*)REDIS_BIO_AOF_FSYNC);
        
    // 线程3: 处理延迟释放
    pthread_create(&thread, &attr, bioProcessBackgroundJobs,
        (void*)REDIS_BIO_LAZY_FREE);
}

// 主要处理文件关闭操作
void bioProcessCloseFile(void *arg) {
    close((long)arg);  // 关闭文件描述符
}

// 处理AOF文件的fsync操作
void bioProcessAOFFsync(void *arg) {
    fsync((long)arg);  // 将AOF缓冲区数据刷新到磁盘
}

// 处理大对象的内存释放
void bioProcessLazyFree(void *arg) {
    lazyfreeInfo *info = (lazyfreeInfo *)arg;
    freeObjectAsync(info);  // 异步释放对象内存
}

typedef struct bio_job {
    time_t time;     // 任务创建时间
    void *arg1;      // 任务参数
    void *arg2;
    void *arg3;
    int type;        // 任务类型
} bio_job;

// 任务处理流程
void *bioProcessBackgroundJobs(void *arg) {
    bio_job *job;
    while(1) {
        // 从任务队列获取任务
        job = listFirst(bio_jobs);
        
        // 根据任务类型处理
        switch(job->type) {
            case REDIS_BIO_CLOSE_FILE:
                bioProcessCloseFile(job->arg1);
                break;
            case REDIS_BIO_AOF_FSYNC:
                bioProcessAOFFsync(job->arg1);
                break;
            case REDIS_BIO_LAZY_FREE:
                bioProcessLazyFree(job->arg1);
                break;
        }
    }
}

void loadDataFromDisk(void) {
    long long start = ustime();
    
    if (server.aof_state == REDIS_AOF_ON) {
        // 优先从AOF文件加载
        loadAppendOnlyFile(server.aof_filename);
    } else {
        // 否则尝试从RDB文件加载
        rdbLoad(server.rdb_filename);
    }
}

aeSetBeforeSleepProc(server.el,beforeSleep);
aeMain(server.el);

void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);
        aeProcessEvents(eventLoop, AE_ALL_EVENTS);
    }
}

int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
    int processed = 0, numevents;
    
    // 1. 检查是否有事件需要处理
    if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) 
        return 0;
    
    // 2. 准备文件事件和时间事件处理
    if (eventLoop->maxfd != -1 || ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
        aeTimeEvent *shortest = NULL;
        struct timeval tv, *tvp;
        
        // 3. 获取最近的时间事件
        if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
            shortest = aeSearchNearestTimer(eventLoop);
            
        // 4. 设置阻塞超时
        if (shortest) {
            // 计算时间差，设置到 tvp
        } else {
            // 根据 AE_DONT_WAIT 决定是否阻塞
            tvp = (flags & AE_DONT_WAIT) ? &tv : NULL;
        }
        
        // 5. 处理文件事件
        numevents = aeApiPoll(eventLoop, tvp);
        for (int j = 0; j < numevents; j++) {
            // 处理读事件
            if (fe->mask & mask & AE_READABLE) {
                fe->rfileProc(eventLoop,fd,fe->clientData,mask);
            }
            // 处理写事件
            if (fe->mask & mask & AE_WRITABLE) {
                fe->wfileProc(eventLoop,fd,fe->clientData,mask);
            }
            processed++;
        }
    }
    
    // 6. 处理时间事件
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop);
        
    return processed;
}

/*
 * 获取可执行事件
 */
static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, numevents = 0;

    // 等待时间
    retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,
            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);

    // 有至少一个事件就绪？
    if (retval > 0) {
        int j;

        // 为已就绪事件设置相应的模式
        // 并加入到 eventLoop 的 fired 数组中
        numevents = retval;
        for (j = 0; j < numevents; j++) {
            int mask = 0;
            struct epoll_event *e = state->events+j;

            if (e->events & EPOLLIN) mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
            if (e->events & EPOLLERR) mask |= AE_WRITABLE;
            if (e->events & EPOLLHUP) mask |= AE_WRITABLE;

            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    }
    
    // 返回已就绪事件个数
    return numevents;
}