Memcached源码分析(线程模型)

作者：fffsssjjj | 来源：互联网 | 2023-09-05 17:34

当客户端发来连接请求，mainthread线程会因listeningsocket发生可读事件而返回（wakeup），并调用e

当客户端发来连接请求&＃xff0c;main thread线程会因listening socket发生可读事件而返回&＃xff08;wake up&＃xff09;&＃xff0c;并调用event_handler()函数来处理该请求&＃xff0c;此函数会调用drive_machie()函数向thread->notify_send_fd写数据触发在创建子线程时调用setup_thread(LIBEVENT_THREAD *me)为管道notify_receive_fd注册了读事件

/*
* File: memcached.c
* drive_machine()
*/
switch(c->state) {
        case conn_listening:
// 5) 以下数行建立与客户端的连接&＃xff0c;得到sfd套接字。
            addrlen &＃61; sizeof(addr);
            if ((sfd &＃61; accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) &＃61;&＃61; -1) {
                if (errno &＃61;&＃61; EAGAIN || errno &＃61;&＃61; EWOULDBLOCK) {
                    /* these are transient, so don&＃39;t log anything */
                    stop &＃61; true;
                } else if (errno &＃61;&＃61; EMFILE) {
                    if (settings.verbose > 0)
                        fprintf(stderr, "Too many open connections\n");
                    accept_new_conns(false);
                    stop &＃61; true;
                } else {
                    perror("accept()");
                    stop &＃61; true;
                }
                break;
            }
            if ((flags &＃61; fcntl(sfd, F_GETFL, 0)) <0 ||
                fcntl(sfd, F_SETFL, flags | O_NONBLOCK) <0) {
                perror("setting O_NONBLOCK");
                close(sfd);
                break;
            }
// 6) 此函数将main thread线程创建的原始套接字以及一些初始化数据&＃xff0c;传递给某个指定的worker thread线程。
            dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,
                                     DATA_BUFFER_SIZE, tcp_transport);
            stop &＃61; true;
            break;

这里就是conn对象的state字段发挥作用的地方了&＃xff1a;&＃xff09;&＃xff0c;drive_machine()函数是一个巨大的switch语句&＃xff0c;它根据conn对象的当前状态&＃xff0c;即state字段的值选择执行不同的分支&＃xff0c;因为listening socket的conn对象被初始化为conn_listening状态&＃xff0c;所以drive_machine()函数会执行switch语句中case conn_listenning的分支&＃xff0c;即创建并分派客户端连接部分。见5)处代码段。

在这里&＃xff0c;main thread线程利用dispatch_conn_new()函数&＃xff0c;来将客户端连接套接字&＃xff08;这里还只是原始套接字&＃xff09;以及其它相关初始化数据&＃xff0c;传递给某个worker thread线程。这里就要用到上一节提到的&＃xff0c;main thread线程与worker thread线程之间的管道&＃xff08;pipe&＃xff09;&＃xff0c;还有线程对象中的new_conn_queue队列。代码如下&＃xff1a;

void dispatch_conn_new(int sfd, enum conn_states init_state, int event_flags,
                       int read_buffer_size, enum network_transport transport) {
// 6.1) 新建一个CQ_ITEM对象&＃xff0c;并通过一个简单的取余机制选择将该CQ_ITEM对象传递给哪个worker thread。
    CQ_ITEM *item &＃61; cqi_new();
    int tid &＃61; (last_thread &＃43; 1) % settings.num_threads;
    LIBEVENT_THREAD *thread &＃61; threads &＃43; tid;
    last_thread &＃61; tid;

// 6.2) 初始化新建的CQ_ITEM对象
    item->sfd &＃61; sfd;
    item->init_state &＃61; init_state;
    item->event_flags &＃61; event_flags;
    item->read_buffer_size &＃61; read_buffer_size;
    item->transport &＃61; transport;

// 6.3) 将CQ_ITEM对象推入new_conn_queue队列。
cq_push(thread->new_conn_queue, item);

// 6.4) 向与worker thread线程连接的管道写入一字节的数据。
    MEMCACHED_CONN_DISPATCH(sfd, thread->thread_id);
    if (write(thread->notify_send_fd, "", 1) !&＃61; 1) {
        perror("Writing to thread notify pipe");
    }
}

而在创建子线程时调用setup_thread(LIBEVENT_THREAD *me)为管道notify_receive_fd注册了读事件

static void setup_thread(LIBEVENT_THREAD *me) {
if (! me->base) {
me->base &＃61; event_init();
if (! me->base) {
fprintf(stderr, "Can&＃39;t allocate event base\n");
exit(1);
}
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) &＃61;&＃61; -1) {
fprintf(stderr, "Can&＃39;t monitor libevent notify pipe\n");
exit(1);
}
cq_init(&me->new_conn_queue);
}

目前网上关于memcached的分析主要是内存管理部分&＃xff0c;下面对memcached的线程模型做下简单分析
有不对的地方还请大家指正,对memcahced和libevent不熟悉的请先google之

先看下memcahced启动时线程处理的流程

memcached的多线程主要是通过实例化多个libevent实现的,分别是一个主线程和n个workers线程
无论是主线程还是workers线程全部通过libevent管理网络事件&＃xff0c;实际上每个线程都是一个单独的libevent实例

主线程负责监听客户端的建立连接请求&＃xff0c;以及accept 连接
workers线程负责处理已经建立好的连接的读写等事件

先看一下大致的图示&＃xff1a;

首先看下主要的数据结构(thread.c)&＃xff1a;

/* An item in the connection queue. */
typedef struct conn_queue_item CQ_ITEM;
struct conn_queue_item {
int sfd;
int init_state;
int event_flags;
int read_buffer_size;
int is_udp;
CQ_ITEM *next;
};

/* An item in the connection queue. */
typedef struct conn_queue_item CQ_ITEM;
struct conn_queue_item {int sfd;int init_state;int event_flags;int read_buffer_size;int is_udp;CQ_ITEM *next;
};

CQ_ITEM 实际上是主线程accept后返回的已建立连接的fd的封装

/* A connection queue. */
typedef struct conn_queue CQ;
struct conn_queue {
CQ_ITEM *head;
CQ_ITEM *tail;
pthread_mutex_t lock;
pthread_cond_t cond;
};

/* A connection queue. */
typedef struct conn_queue CQ;
struct conn_queue {CQ_ITEM *head;CQ_ITEM *tail;pthread_mutex_t lock;pthread_cond_t cond;
};

CQ是一个管理CQ_ITEM的单向链表

typedef struct {
pthread_t thread_id; /* unique ID of this thread */
struct event_base *base; /* libevent handle this thread uses */
struct event notify_event; /* listen event for notify pipe */
int notify_receive_fd; /* receiving end of notify pipe */
int notify_send_fd; /* sending end of notify pipe */
CQ new_conn_queue; /* queue of new connections to handle */
} LIBEVENT_THREAD;

typedef struct {pthread_t thread_id; /* unique ID of this thread */struct event_base *base; /* libevent handle this thread uses */struct event notify_event; /* listen event for notify pipe */int notify_receive_fd; /* receiving end of notify pipe */int notify_send_fd; /* sending end of notify pipe */CQ new_conn_queue; /* queue of new connections to handle */
} LIBEVENT_THREAD;

这是memcached里的线程结构的封装&＃xff0c;可以看到每个线程都包含一个CQ队列&＃xff0c;一条通知管道pipe
和一个libevent的实例event_base

另外一个重要的最重要的结构是对每个网络连接的封装conn

typedef struct{
int sfd;
int state;
struct event event;
short which;
char *rbuf;
... //这里省去了很多状态标志和读写buf信息等
}conn;

typedef struct{int sfd;int state;struct event event;short which;char *rbuf;... //这里省去了很多状态标志和读写buf信息等
}conn;

memcached主要通过设置/转换连接的不同状态&＃xff0c;来处理事件&＃xff08;核心函数是drive_machine&＃xff09;

下面看下线程的初始化流程&＃xff1a;

在memcached.c的main函数中&＃xff0c;首先对主线程的libevent做了初始化

/* initialize main thread libevent instance */
main_base &＃61; event_init();

/* initialize main thread libevent instance */main_base &＃61; event_init();

然后初始化所有的workers线程&＃xff0c;并启动&＃xff0c;启动过程细节在后面会有描述

C代码

/* start up worker threads if MT mode */
thread_init(settings.num_threads, main_base);

/* start up worker threads if MT mode */
thread_init(settings.num_threads, main_base);

接着主线程调用&＃xff08;这里只分析tcp的情况&＃xff0c;目前memcached支持udp方式&＃xff09;

server_socket(settings.port, 0)

server_socket(settings.port, 0)

这个方法主要是封装了创建监听socket&＃xff0c;绑定地址&＃xff0c;设置非阻塞模式并注册监听socket的
libevent 读事件等一系列操作

然后主线程调用

/* enter the event loop */
event_base_loop(main_base, 0);

/* enter the event loop */
event_base_loop(main_base, 0);

这时主线程启动开始通过libevent来接受外部连接请求&＃xff0c;整个启动过程完毕

下面看看thread_init是怎样启动所有workers线程的&＃xff0c;看一下thread_init里的核心代码

C代码

void thread_init(int nthreads, struct event_base *main_base) {
//。。。省略
threads &＃61; malloc(sizeof(LIBEVENT_THREAD) * nthreads);
if (! threads) {
perror("Can&＃39;t allocate thread descriptors");
exit(1);
}
threads[0].base &＃61; main_base;
threads[0].thread_id &＃61; pthread_self();
for (i &＃61; 0; i < nthreads; i&＃43;&＃43;) {
int fds[2];
if (pipe(fds)) {
perror("Can&＃39;t create notify pipe");
exit(1);
}
threads[i].notify_receive_fd &＃61; fds[0];
threads[i].notify_send_fd &＃61; fds[1];
setup_thread(&threads[i]);
}
/* Create threads after we&＃39;ve done all the libevent setup. */
for (i &＃61; 1; i < nthreads; i&＃43;&＃43;) {
create_worker(worker_libevent, &threads[i]);
}
}

void thread_init(int nthreads, struct event_base *main_base) {//。。。省略threads &＃61; malloc(sizeof(LIBEVENT_THREAD) * nthreads);if (! threads) {perror("Can&＃39;t allocate thread descriptors");exit(1);}threads[0].base &＃61; main_base;threads[0].thread_id &＃61; pthread_self();for (i &＃61; 0; i }

threads的声明是这样的
static LIBEVENT_THREAD *threads;

thread_init首先malloc线程的空间&＃xff0c;然后第一个threads作为主线程&＃xff0c;其余都是workers线程
然后为每个线程创建一个pipe&＃xff0c;这个pipe被用来作为主线程通知workers线程有新的连接到达

看下setup_thread

static void setup_thread(LIBEVENT_THREAD *me) {
if (! me->base) {
me->base &＃61; event_init();
if (! me->base) {
fprintf(stderr, "Can&＃39;t allocate event base\n");
exit(1);
}
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) &＃61;&＃61; -1) {
fprintf(stderr, "Can&＃39;t monitor libevent notify pipe\n");
exit(1);
}
cq_init(&me->new_conn_queue);
}

static void setup_thread(LIBEVENT_THREAD *me) {if (! me->base) {me->base &＃61; event_init();if (! me->base) {fprintf(stderr, "Can&＃39;t allocate event base\n");exit(1);}}/* Listen for notifications from other threads */event_set(&me->notify_event, me->notify_receive_fd,EV_READ | EV_PERSIST, thread_libevent_process, me);event_base_set(me->base, &me->notify_event);if (event_add(&me->notify_event, 0) &＃61;&＃61; -1) {fprintf(stderr, "Can&＃39;t monitor libevent notify pipe\n");exit(1);}cq_init(&me->new_conn_queue);
}

setup_thread主要是创建所有workers线程的libevent实例&＃xff08;主线程的libevent实例在main函数中已经建立&＃xff09;

由于之前 threads[0].base &＃61; main_base;所以第一个线程&＃xff08;主线程&＃xff09;在这里不会执行event_init()
然后就是注册所有workers线程的管道读端的libevent的读事件&＃xff0c;等待主线程的通知
最后在该方法里将所有的workers的CQ初始化了

create_worker实际上就是真正启动了线程&＃xff0c;pthread_create调用worker_libevent方法&＃xff0c;该方法执行
event_base_loop启动该线程的libevent

这里我们需要记住每个workers线程目前只在自己线程的管道的读端有数据时可读时触发&＃xff0c;并调用
thread_libevent_process方法

thread_libevent_process方法----->

conn_new---->注册event_handler&＃xff08;drive__machine方法&＃xff09;
看一下这个函数

static void thread_libevent_process(int fd, short which, void *arg){

LIBEVENT_THREAD *me &＃61; arg;
CQ_ITEM *item;
char buf[1];
if (read(fd, buf, 1) !&＃61; 1)
if (settings.verbose > 0)
fprintf(stderr, "Can&＃39;t read from libevent pipe\n");
item &＃61; cq_peek(&me->new_conn_queue);
if (NULL !&＃61; item) {
conn *c &＃61; conn_new(item->sfd, item->init_state, item->event_flags,
item->read_buffer_size, item->is_udp, me->base);
。。。//省略
}
}

static void thread_libevent_process(int fd, short which, void *arg){LIBEVENT_THREAD *me &＃61; arg;CQ_ITEM *item;char buf[1];if (read(fd, buf, 1) !&＃61; 1)if (settings.verbose > 0)fprintf(stderr, "Can&＃39;t read from libevent pipe\n");item &＃61; cq_peek(&me->new_conn_queue);if (NULL !&＃61; item) {conn *c &＃61; conn_new(item->sfd, item->init_state, item->event_flags,item->read_buffer_size, item->is_udp, me->base);。。。//省略}
}

函数参数的fd是这个线程的管道读端的描述符
首先将管道的1个字节通知信号读出&＃xff08;这是必须的&＃xff0c;在水平触发模式下如果不处理该事件&＃xff0c;则会被循环通知&＃xff0c;知道事件被处理&＃xff09;

cq_peek是从该线程的CQ队列中取队列头的一个CQ_ITEM,这个CQ_ITEM是被主线程丢到这个队列里的&＃xff0c;item->sfd是已经建立的连接
的描述符&＃xff0c;通过conn_new函数为该描述符注册libevent的读事件&＃xff0c;me->base是代表自己的一个线程结构体&＃xff0c;就是说对该描述符的事件
处理交给当前这个workers线程处理,conn_new方法的最重要的内容是&＃xff1a;

C代码

conn *conn_new(const int sfd, const int init_state, const int event_flags,
const int read_buffer_size, const bool is_udp, struct event_base *base) {
。。。
event_set(&c->event, sfd, event_flags, event_handler, (void *)c);
event_base_set(base, &c->event);
c->ev_flags &＃61; event_flags;
if (event_add(&c->event, 0) &＃61;&＃61; -1) {
if (conn_add_to_freelist(c)) {
conn_free(c);
}
perror("event_add");
return NULL;
}
。。。
}

conn *conn_new(const int sfd, const int init_state, const int event_flags,const int read_buffer_size, const bool is_udp, struct event_base *base) {。。。event_set(&c->event, sfd, event_flags, event_handler, (void *)c);event_base_set(base, &c->event);c->ev_flags &＃61; event_flags;if (event_add(&c->event, 0) &＃61;&＃61; -1) {if (conn_add_to_freelist(c)) {conn_free(c);}perror("event_add");return NULL;}。。。
}

可以看到新的连接被注册了一个事件&＃xff08;实际是EV_READ|EV_PERSIST&＃xff09;,由当前线程处理&＃xff08;因为这里的event_base是该workers线程自己的&＃xff09;
当该连接有可读数据时会回调event_handler函数&＃xff0c;实际上event_handler里主要是调用memcached的核心方法drive_machine

最后看看主线程是如何通知workers线程处理新连接的&＃xff0c;主线程的libevent注册的是监听socket描述字的可读事件&＃xff0c;就是说
当有建立连接请求时&＃xff0c;主线程会处理&＃xff0c;回调的函数是也是event_handler&＃xff08;因为实际上主线程也是通过conn_new初始化的监听socket 的libevent可读事件&＃xff09;

最后看看memcached网络事件处理的最核心部分- drive_machine
需要铭记于心的是drive_machine是多线程环境执行的&＃xff0c;主线程和workers都会执行drive_machine

C代码

static void drive_machine(conn *c) {
bool stop &＃61; false;
int sfd, flags &＃61; 1;
socklen_t addrlen;
struct sockaddr_storage addr;
int res;
assert(c !&＃61; NULL);
while (!stop) {
switch(c->state) {
case conn_listening:
addrlen &＃61; sizeof(addr);
if ((sfd &＃61; accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) &＃61;&＃61; -1) {
//省去n多错误情况处理
break;
}
if ((flags &＃61; fcntl(sfd, F_GETFL, 0)) < 0 ||
fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
perror("setting O_NONBLOCK");
close(sfd);
break;
}
dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,
DATA_BUFFER_SIZE, false);
break;
case conn_read:
if (try_read_command(c) !&＃61; 0) {
continue;
}
....//省略
}
}

static void drive_machine(conn *c) {bool stop &＃61; false;int sfd, flags &＃61; 1;socklen_t addrlen;struct sockaddr_storage addr;int res;assert(c !&＃61; NULL);while (!stop) {switch(c->state) {case conn_listening:addrlen &＃61; sizeof(addr);if ((sfd &＃61; accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) &＃61;&＃61; -1) {//省去n多错误情况处理break;}if ((flags &＃61; fcntl(sfd, F_GETFL, 0)) <0 ||fcntl(sfd, F_SETFL, flags | O_NONBLOCK) <0) {perror("setting O_NONBLOCK");close(sfd);break;}dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,DATA_BUFFER_SIZE, false);break;case conn_read:if (try_read_command(c) !&＃61; 0) {continue;}....//省略} }

首先大家不到被while循环误导&＃xff08;大部分做java的同学都会马上联想到是个周而复始的loop&＃xff09;其实while通常满足一个
case后就会break了&＃xff0c;这里用while是考虑到垂直触发方式下&＃xff0c;必须读到EWOULDBLOCK错误才可以

言归正传&＃xff0c;drive_machine主要是通过当前连接的state来判断该进行何种处理&＃xff0c;因为通过libevent注册了读写时间后回调的都是
这个核心函数&＃xff0c;所以实际上我们在注册libevent相应事件时&＃xff0c;会同时把事件状态写到该conn结构体里&＃xff0c;libevent进行回调时会把
该conn结构作为参数传递过来&＃xff0c;就是该方法的形参

memcached里连接的状态通过一个enum声明

C代码

enum conn_states {

conn_listening, /** the socket which listens for connections */
conn_read, /** reading in a command line */
conn_write, /** writing out a simple response */
conn_nread, /** reading in a fixed number of bytes */
conn_swallow, /** swallowing unnecessary bytes w/o storing */
conn_closing, /** closing this connection */
conn_mwrite, /** writing out many items sequentially */
};

enum conn_states {conn_listening, /** the socket which listens for connections */conn_read, /** reading in a command line */conn_write, /** writing out a simple response */conn_nread, /** reading in a fixed number of bytes */conn_swallow, /** swallowing unnecessary bytes w/o storing */conn_closing, /** closing this connection */conn_mwrite, /** writing out many items sequentially */
};

实际对于case conn_listening:这种情况是主线程自己处理的&＃xff0c;workers线程永远不会执行此分支
我们看到主线程进行了accept后调用了
dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,DATA_BUFFER_SIZE, false);

这个函数就是通知workers线程的地方&＃xff0c;看看

C代码

void dispatch_conn_new(int sfd, int init_state, int event_flags,
int read_buffer_size, int is_udp) {
CQ_ITEM *item &＃61; cqi_new();
int thread &＃61; (last_thread &＃43; 1) % settings.num_threads;
last_thread &＃61; thread;
item->sfd &＃61; sfd;
item->init_state &＃61; init_state;
item->event_flags &＃61; event_flags;
item->read_buffer_size &＃61; read_buffer_size;
item->is_udp &＃61; is_udp;
cq_push(&threads[thread].new_conn_queue, item);
MEMCACHED_CONN_DISPATCH(sfd, threads[thread].thread_id);
if (write(threads[thread].notify_send_fd, "", 1) !&＃61; 1) {
perror("Writing to thread notify pipe");
}
}

void dispatch_conn_new(int sfd, int init_state, int event_flags,int read_buffer_size, int is_udp) {CQ_ITEM *item &＃61; cqi_new();int thread &＃61; (last_thread &＃43; 1) % settings.num_threads;last_thread &＃61; thread;item->sfd &＃61; sfd;item->init_state &＃61; init_state;item->event_flags &＃61; event_flags;item->read_buffer_size &＃61; read_buffer_size;item->is_udp &＃61; is_udp;cq_push(&threads[thread].new_conn_queue, item);MEMCACHED_CONN_DISPATCH(sfd, threads[thread].thread_id);if (write(threads[thread].notify_send_fd, "", 1) !&＃61; 1) {perror("Writing to thread notify pipe");}
}

可以清楚的看到&＃xff0c;主线程首先创建了一个新的CQ_ITEM&＃xff0c;然后通过round robin策略选择了一个thread
并通过cq_push将这个CQ_ITEM放入了该线程的CQ队列里&＃xff0c;那么对应的workers线程是怎么知道的呢

就是通过这个
write(threads[thread].notify_send_fd, "", 1&＃xff09;
向该线程管道写了1字节数据&＃xff0c;则该线程的libevent立即回调了thread_libevent_process方法&＃xff08;上面已经描述过&＃xff09;

然后那个线程取出item,注册读时间&＃xff0c;当该条连接上有数据时&＃xff0c;最终也会回调drive_machine方法&＃xff0c;也就是
drive_machine方法的 case conn_read:等全部是workers处理的&＃xff0c;主线程只处理conn_listening 建立连接这个

这部分代码确实比较多&＃xff0c;没法全部贴出来&＃xff0c;请大家参考源码&＃xff0c;最新版本1.2.6&＃xff0c;我省去了很多优化的地方
比如&＃xff0c;每个CQ_ITEM被malloc时会一次malloc很多个&＃xff0c;以减小碎片的产生等等细节。

推荐阅读

cmd
Go Cobra命令行工具入门教程

本文介绍了Go语言实现的命令行工具Cobra的基本概念、安装方法和入门实践。Cobra被广泛应用于各种项目中，如Kubernetes、Hugo和Github CLI等。通过使用Cobra，我们可以快速创建命令行工具，适用于写测试脚本和各种服务的Admin CLI。文章还通过一个简单的demo演示了Cobra的使用方法。 ... [详细]

蜡笔小新 2023-12-12 20:02:41
const
差分约束系统求解House Man跳跃问题的思路与方法

本文讨论了使用差分约束系统求解House Man跳跃问题的思路与方法。给定一组不同高度，要求从最低点跳跃到最高点，每次跳跃的距离不超过D，并且不能改变给定的顺序。通过建立差分约束系统，将问题转化为图的建立和查询距离的问题。文章详细介绍了建立约束条件的方法，并使用SPFA算法判环并输出结果。同时还讨论了建边方向和跳跃顺序的关系。 ... [详细]

蜡笔小新 2023-12-14 11:49:51
get
Java太阳系小游戏分析和源码详解

本文介绍了一个基于Java的太阳系小游戏的分析和源码详解。通过对面向对象的知识的学习和实践，作者实现了太阳系各行星绕太阳转的效果。文章详细介绍了游戏的设计思路和源码结构，包括工具类、常量、图片加载、面板等。通过这个小游戏的制作，读者可以巩固和应用所学的知识，如类的继承、方法的重载与重写、多态和封装等。 ... [详细]

蜡笔小新 2023-12-14 19:53:34
get
Nginx使用（server参数配置）

本文介绍了Nginx的使用，重点讲解了server参数配置，包括端口号、主机名、根目录等内容。同时，还介绍了Nginx的反向代理功能。 ... [详细]

蜡笔小新 2023-12-14 17:08:34
get
Java猜拳小游戏代码

本文介绍了一个Java猜拳小游戏的代码，通过使用Scanner类获取用户输入的拳的数字，并随机生成计算机的拳，然后判断胜负。该游戏可以选择剪刀、石头、布三种拳，通过比较两者的拳来决定胜负。 ... [详细]

蜡笔小新 2023-12-14 15:39:08
get
九度OnlineJudge之1002：Grading问题的解决方法

本文介绍了九度OnlineJudge中的1002题目“Grading”的解决方法。该题目要求设计一个公平的评分过程，将每个考题分配给3个独立的专家，如果他们的评分不一致，则需要请一位裁判做出最终决定。文章详细描述了评分规则，并给出了解决该问题的程序。 ... [详细]

蜡笔小新 2023-12-14 13:00:09
bit
Open judge C16H: Magical Balls 快速幂+逆元问题解析

本文主要解析了Open judge C16H问题中涉及到的Magical Balls的快速幂和逆元算法，并给出了问题的解析和解决方法。详细介绍了问题的背景和规则，并给出了相应的算法解析和实现步骤。通过本文的解析，读者可以更好地理解和解决Open judge C16H问题中的Magical Balls部分。 ... [详细]

蜡笔小新 2023-12-14 12:03:27
c语言
c语言\n不换行,c语言printf不换行

$c语言\n不换行,c语言printf不换行$

本文目录一览：1、C语言不换行输入2、c语言的 ... [详细]

蜡笔小新 2023-12-14 11:05:35
byte
Oracle中tnsnames.ora的作用和配置方法

本文介绍了Oracle数据库中tnsnames.ora文件的作用和配置方法。tnsnames.ora文件在数据库启动过程中会被读取，用于解析LOCAL_LISTENER，并且与侦听无关。文章还提供了配置LOCAL_LISTENER和1522端口的示例，并展示了listener.ora文件的内容。 ... [详细]

蜡笔小新 2023-12-14 07:44:06
get
的错误消息：

ZSI.generate.Wsdl2PythonError: unsupported local simpleType restriction ... [详细]

蜡笔小新 2023-12-13 20:28:08
get
Go GUIlxn/walk 学习3.菜单栏和工具栏的具体实现

本文介绍了使用Go语言的GUI库lxn/walk实现菜单栏和工具栏的具体方法，包括消息窗口的产生、文件放置动作响应和提示框的应用。部分代码来自上一篇博客和lxn/walk官方示例。文章提供了学习GUI开发的实际案例和代码示例。 ... [详细]

蜡笔小新 2023-12-12 20:56:55
const
clone的fork与pthread_create创建线程有何不同

本文讨论了clone的fork与pthread_create创建线程的不同之处。进程是一个指令执行流及其执行环境，其执行环境是一个系统资源的集合。在调用系统调用fork创建一个进程时，子进程只是完全复制父进程的资源，这样得到的子进程独立于父进程，具有良好的并发性。但是二者之间的通讯需要通过专门的通讯机制，另外通过fork创建子进程系统开销很大。因此，在某些情况下，使用clone或pthread_create创建线程可能更加高效。 ... [详细]

蜡笔小新 2023-12-12 20:00:06
select
修复安装win10失败并提示“磁盘布局不受UEFI固件支持”的方法

本文介绍了修复安装win10失败并提示“磁盘布局不受UEFI固件支持”的方法。首先解释了UEFI的概念和作用，然后提供了两种解决方法。第一种方法是在bios界面中将Boot Mode设置为Legacy Support，Boot Priority设置为Legacy First，并关闭UEFI。第二种方法是使用U盘启动盘进入PE系统，运行磁盘分区工具DiskGenius，将硬盘的分区表设置为gpt格式，并留出288MB的内存。最后，通过运行界面输入命令cmd来完成设置。 ... [详细]

蜡笔小新 2023-12-11 18:42:50
bit
Android工程师面试准备及设计模式使用场景

本文介绍了Android工程师面试准备的经验，包括面试流程和重点准备内容。同时，还介绍了建造者模式的使用场景，以及在Android开发中的具体应用。 ... [详细]

蜡笔小新 2023-12-11 18:25:26
byte
在虚拟服务器上安装oracle 10g客户端的问题及解决方法

本文讨论了在VMWARE5.1的虚拟服务器Windows Server 2008R2上安装oracle 10g客户端时出现的问题，并提供了解决方法。错误日志显示了异常访问违例，通过分析日志中的问题帧，找到了解决问题的线索。文章详细介绍了解决方法，帮助读者顺利安装oracle 10g客户端。 ... [详细]

蜡笔小新 2023-12-11 13:08:10

fffsssjjj

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章