Inhaltsverzeichnis
one-connection-per-thread
线程池与epoll
线程池函数调用关系
one-connection-per-thread函数调用关系
Heim Datenbank MySQL-Tutorial MySQL详解(8)----------MySQL线程池总结(二)_MySQL

MySQL详解(8)----------MySQL线程池总结(二)_MySQL

Jun 01, 2016 pm 12:59 PM
线程

这篇文章是对上篇文章的一个补充,主要围绕以下两点展开,one-connection-per-thread的实现方式以及线程池中epoll的使用。

one-connection-per-thread

根据scheduler_functions的模板,我们也可以列出one-connection-per-thread方式的几个关键函数。

static scheduler_functions con_per_functions=

{ max_connection+1, // max_threads

NULL,

NULL,

NULL, // init

Init_new_connection_handler_thread, // init_new_connection_thread

create_thread_to_handle_connection, // add_connection

NULL, // thd_wait_begin

NULL, // thd_wait_end

NULL, // post_kill_notification

one_thread_per_connection_end, // end_thread

NULL // end

};
Nach dem Login kopieren

1.init_new_connection_handler_thread

这个接口比较简单,主要是调用pthread_detach,将线程设置为detach状态,线程结束后自动释放所有资源。

2.create_thread_to_handle_connection

这个接口是处理新连接的接口,对于线程池而言,会从thread_id%group_size对应的group中获取一个线程来处理,而one-connection-per-thread方式则会判断是否有thread_cache可以使用,如果没有则新建线程来处理。具体逻辑如下:

(1).判断缓存的线程数是否使用完(比较blocked_pthread_count 和wake_pthread大小)

(2).若还有缓存线程,将thd加入waiting_thd_list的队列,唤醒一个等待COND_thread_cache的线程

(3).若没有,创建一个新的线程处理,线程的入口函数是do_handle_one_connection

(4).调用add_global_thread加入thd数组。

3.do_handle_one_connection

这个接口被create_thread_to_handle_connection调用,处理请求的主要实现接口。

(1).循环调用do_command,从socket中读取网络包,并且解析执行;

(2). 当远程客户端发送关闭连接COMMAND(比如COM_QUIT,COM_SHUTDOWN)时,退出循环

(3).调用close_connection关闭连接(thd->disconnect());

(4).调用one_thread_per_connection_end函数,确认是否可以复用线程

(5).根据返回结果,确定退出工作线程还是继续循环执行命令。

4.one_thread_per_connection_end

判断是否可以复用线程(thread_cache)的主要函数,逻辑如下:

(1).调用remove_global_thread,移除线程对应的thd实例

(2).调用block_until_new_connection判断是否可以重用thread

(3).判断缓存的线程是否超过阀值,若没有,则blocked_pthread_count++;

(4).阻塞等待条件变量COND_thread_cache

(5).被唤醒后,表示有新的thd需要重用线程,将thd从waiting_thd_list中移除,使用thd初始化线程的thd->thread_stack

(6).调用add_global_thread加入thd数组。

(7).如果可以重用,返回false,否则返回ture

线程池与epoll

在引入线程池之前,server层只有一个监听线程,负责监听mysql端口和本地unixsocket的请求,对于每个新的连接,都会分配一个独立线程来处理,因此监听线程的任务比较轻松,mysql通过poll或select方式来实现IO的多路复用。引入线程池后,除了server层的监听线程,每个group都有一个监听线程负责监听group内的所有连接socket的连接请求,工作线程不负责监听,只处理请求。对于overscribe为1000的线程池设置,每个监听线程需要监听1000个socket的请求,监听线程采用epoll方式来实现监听。

Select,poll,epoll都是IO多路复用机制,IO多路复用通过一种机制,可以监听多个fd(描述符),比如socket,一旦某个fd就绪(读就绪或写就绪),能够通知程序进行相应的读写操作。epoll相对于select和poll有了很大的改进,首先epoll通过epoll_ctl函数注册,注册时,将所有fd拷贝进内核,只拷贝一次不需要重复拷贝,而每次调用poll或select时,都需要将fd集合从用户空间拷贝到内核空间(epoll通过epoll_wait进行等待);其次,epoll为每个描述符指定了一个回调函数,当设备就绪时,唤醒等待者,通过回调函数将描述符加入到就绪链表,无需像select,poll方式采用轮询方式;最后select默认只支持1024个fd,epoll则没有限制,具体数字可以参考cat /proc/sys/fs/file-max的设置。epoll贯穿在线程池使用的过程中,下面我就epoll的创建,使用和销毁生命周期来描述epoll在线程中是如何使用的。

线程池初始化,epoll通过epoll_create函数创建epoll文件描述符,实现函数是thread_group_init;端口监听线程监听到请求后,创建socket,并创建THD和connection对象,放在对应的group队列中;工作线程获取该connection对象时,若还未登录,则进行登录验证若socket还未注册到epoll,则调用epoll_ctl进行注册,注册方式是EPOLL_CTL_ADD,并将connection对象放入epoll_event结构体中若是老连接的请求,仍然需要调用epoll_ctl注册,注册方式是EPOLL_CTL_MODgroup内的监听线程调用epoll_wait来监听注册的fd,epoll是一种同步IO方式,所以会进行等待请求到来时,获取epoll_event结构体中的connection,放入到group中的队列线程池销毁时,调用thread_group_close将epoll关闭。

备注:

1.注册在epoll的fd,若请求就绪,则将对应的event放入到events数组,并将该fd的事务类型清空,因此对于老的连接请求,依然需要调用epoll_ctl(pollfd, EPOLL_CTL_MOD, fd, &ev)来注册。

线程池函数调用关系

(1)创建epoll

tp_init->thread_group_init->tp_set_threadpool_size->io_poll_create->epoll_create

(2)关闭epoll

tp_end->thread_group_close->thread_group_destroy->close(pollfd)

(3)关联socket描述符

handle_event->start_io->io_poll_associate_fd->io_poll_start_read->epoll_ctl

(4)处理连接请求

handle_event->threadpool_process_request->do_command->dispatch_command->mysql_parse->mysql_execute_command

(5)工作线程空闲时

worker_main->get_event->pthread_cond_timedwait

等待thread_pool_idle_timeout后,退出。

(6)监听epoll

worker_main->get_event->listener->io_poll_wait->epoll_wait

(7)端口监听线程

main->mysqld_main->handle_connections_sockets->poll

one-connection-per-thread函数调用关系

(1) 工作线程等待请求

handle_one_connection->do_handle_one_connection->do_command->

my_net_read->net_read_packet->net_read_packet_header->net_read_raw_loop->

vio_read->vio_socket_io_wait->vio_io_wait->poll

备注:与线程池的工作线程有监听线程帮助其监听请求不同,one-connection-per-thread方式的工作线程在空闲时,会调用poll阻塞等待网络包过来;

而线程池的工作线程只需要专心处理请求即可,所以使用也更充分。

(2)端口监听线程

与线程池的(7)相同

Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Heiße KI -Werkzeuge

Undresser.AI Undress

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

Clothoff.io

KI-Kleiderentferner

AI Hentai Generator

AI Hentai Generator

Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

R.E.P.O. Energiekristalle erklärten und was sie tun (gelber Kristall)
2 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌
Repo: Wie man Teamkollegen wiederbelebt
1 Monate vor By 尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Abenteuer: Wie man riesige Samen bekommt
4 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌

Heiße Werkzeuge

Notepad++7.3.1

Notepad++7.3.1

Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version

SublimeText3 chinesische Version

Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1

Senden Sie Studio 13.0.1

Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6

Dreamweaver CS6

Visuelle Webentwicklungstools

SublimeText3 Mac-Version

SublimeText3 Mac-Version

Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Was bedeuten 8 Kerne und 16 Threads? Was bedeuten 8 Kerne und 16 Threads? Feb 02, 2023 am 11:26 AM

8-Kern bedeutet, dass die CPU über 8 physische Kerne verfügt, und 16-Thread bedeutet, dass die CPU bis zu 16 Threads gleichzeitig ausführen kann. Die Anzahl der Kerne und Threads sind wichtige Leistungsindikatoren einer Computer-CPU. Je höher die Anzahl der Kerne der CPU, desto höher die Anzahl der Threads und desto günstiger die gleichzeitige Ausführung mehrerer Programme. weil die Anzahl der Threads der Anzahl entspricht, die die CPU zu einem bestimmten Zeitpunkt gleichzeitig ausführen kann. Die Anzahl der parallel zu verarbeitenden Aufgaben. Multithreading kann die superskalare Verarbeitung mit großen Problemen außerhalb der Reihenfolge maximieren, die Auslastung von Prozessor-Rechnerkomponenten verbessern und Verzögerungen beim Speicherzugriff verringern, die durch Datenkorrelation oder Cache-Fehler verursacht werden.

Gleichzeitige C++-Programmierung: Wie vermeidet man Thread-Aushungerung und Prioritätsumkehr? Gleichzeitige C++-Programmierung: Wie vermeidet man Thread-Aushungerung und Prioritätsumkehr? May 06, 2024 pm 05:27 PM

Um Thread-Aushunger zu vermeiden, können Sie faire Sperren verwenden, um eine faire Zuweisung von Ressourcen sicherzustellen, oder Thread-Prioritäten festlegen. Um die Prioritätsumkehr zu lösen, können Sie die Prioritätsvererbung verwenden, um die Priorität des Threads, der die Ressource enthält, vorübergehend zu erhöhen, oder die Sperrenerhöhung verwenden, um die Priorität des Threads zu erhöhen, der die Ressource benötigt.

Gleichzeitige C++-Programmierung: Wie führt man Thread-Beendigung und -Abbruch durch? Gleichzeitige C++-Programmierung: Wie führt man Thread-Beendigung und -Abbruch durch? May 06, 2024 pm 02:12 PM

Zu den Thread-Beendigungs- und Abbruchmechanismen in C++ gehören: Thread-Beendigung: std::thread::join() blockiert den aktuellen Thread, bis der Ziel-Thread die Ausführung abschließt. std::thread::detach() trennt den Ziel-Thread von der Thread-Verwaltung. Thread-Abbruch: std::thread::request_termination() fordert den Ziel-Thread auf, die Ausführung zu beenden; std::thread::get_id() erhält die Ziel-Thread-ID und kann mit std::terminate() verwendet werden, um das Ziel sofort zu beenden Faden. Im tatsächlichen Kampf ermöglicht request_termination() dem Thread, den Zeitpunkt der Beendigung zu bestimmen, und join() stellt dies in der Hauptzeile sicher

Java-Fehler: JavaFX-Thread steckt fest, wie man damit umgeht und ihn vermeidet Java-Fehler: JavaFX-Thread steckt fest, wie man damit umgeht und ihn vermeidet Jun 24, 2023 pm 05:52 PM

Bei der Entwicklung von JavaFX-Anwendungen treten häufig Fehler auf, bei denen der JavaFX-Thread hängen bleibt. Solche Fehler sind unterschiedlich schwerwiegend und können die Stabilität und Leistung des Programms beeinträchtigen. Um den normalen Betrieb des Programms sicherzustellen, müssen wir die Ursachen und Lösungen von JavaFX-Thread-Steckfehlern verstehen und wissen, wie wir verhindern können, dass dieser Fehler auftritt. 1. Die Ursache für den Fehler „JavaFX-Thread steckt fest“ JavaFX ist ein Multithread-UI-Anwendungsframework, das es Programmen ermöglicht, über einen längeren Zeitraum in Hintergrundthreads ausgeführt zu werden.

Was ist die kleinste Befehlsflusseinheit, wenn ein Programm ausgeführt wird? Was ist die kleinste Befehlsflusseinheit, wenn ein Programm ausgeführt wird? Aug 23, 2022 pm 02:16 PM

„Thread“ ist die kleinste Einheit des Befehlsflusses, wenn ein Programm ausgeführt wird. Ein Prozess bezieht sich auf ein Programm mit bestimmten unabhängigen Funktionen. Ein Thread ist Teil des Prozesses und beschreibt den Ausführungsstatus des Befehlsflusses. Der Thread ist die kleinste Einheit des Befehlsausführungsflusses im Prozess und die Grundeinheit der CPU-Planung. Ein Thread ist ein Ausführungsprozess einer Aufgabe (ein Programmsegment); ein Thread belegt keinen Speicherplatz, er ist im Speicherbereich des Prozesses enthalten. Innerhalb desselben Prozesses teilen sich mehrere Threads die Ressourcen des Prozesses; ein Prozess verfügt über mindestens einen Thread.

Analyse des Unterschieds zwischen Threads und Prozessen in der Go-Sprache Analyse des Unterschieds zwischen Threads und Prozessen in der Go-Sprache Apr 03, 2024 pm 01:39 PM

Prozesse und Threads in der Go-Sprache: Prozess: Eine unabhängig laufende Programminstanz mit eigenen Ressourcen und eigenem Adressraum. Thread: Eine Ausführungseinheit innerhalb eines Prozesses, die Prozessressourcen und Adressraum gemeinsam nutzt. Merkmale: Prozess: hoher Overhead, gute Isolation, unabhängige Planung. Threads: geringer Overhead, gemeinsame Ressourcen, interne Planung. Praxisfall: Prozess: Isolieren lang laufender Aufgaben. Threads: Verarbeiten Sie große Datenmengen gleichzeitig.

Was ist der Unterschied zwischen Coroutinen und Threads in der Go-Sprache? Was ist der Unterschied zwischen Coroutinen und Threads in der Go-Sprache? Feb 02, 2023 pm 06:10 PM

Unterschiede: 1. Ein Thread kann mehrere Coroutinen haben, und ein Prozess kann auch mehrere Coroutinen allein haben. 2. Threads sind ein Synchronisationsmechanismus, während Coroutinen asynchron sind. 3. Coroutinen können den Status des letzten Aufrufs beibehalten. Threads funktionieren nicht 4. Threads sind präventiv, während Coroutinen nicht präemptiv sind. 5. Threads sind geteilte CPU-Ressourcen und Coroutinen erfordern Threads zum Hosten und Ausführen.

Wie können wir einen Timer-Thread in Java implementieren? Wie können wir einen Timer-Thread in Java implementieren? Aug 30, 2023 pm 02:49 PM

Die Timer-Klasse plant die einmalige oder wiederholte Ausführung einer Aufgabe zu einem bestimmten Zeitpunkt. Es kann auch im Hintergrund als Daemon-Thread ausgeführt werden. Um einen Timer einem Daemon-Thread zuzuordnen, müssen Sie einen Konstruktor mit einem booleschen Wert verwenden. Timer planen Aufgaben mit einer festen Verzögerung und einer festen Rate. Wenn bei einer festen Verzögerung eine Ausführung durch den System-GC verzögert wird, werden auch die anderen Ausführungen verzögert, und jede Ausführung wird entsprechend der vorherigen Ausführung verzögert. Wenn bei einer festen Rate eine Ausführung durch den System-GC verzögert wird, erfolgen zwei bis drei Ausführungen nacheinander, um die feste Rate abzudecken, die der Startzeit der ersten Ausführung entspricht. Die Timer-Klasse stellt die Methode cancel() zum Abbrechen des Timers bereit. Wenn diese Methode aufgerufen wird, läuft der Timer ab. Die Timer-Klasse implementiert nur Ti

See all articles