Analyse du processus de connexion au serveur MySQL

Mysqld est le processus principal du serveur MySQL. On peut dire que mysqld est le véritable noyau de MySQL, et tout le travail est effectué autour du processus mysqld. Donc, pour disséquer le géant mysql, le code de mysqld est la meilleure avancée.

Tout commence à partir de la fonction familière main() En fait, cela commence à partir de la fonction mysqld_main(). Ces codes sont tous dans mysqld.cc. mysqld_main() appelle ensuite win_main()). La fonction win_main() effectue principalement un travail d'initialisation.

Une fois le travail d'initialisation terminé, MySQL est prêt à accepter les connexions. Ensuite, notre fonction protagoniste Handle_connections_methods() apparaît. La tâche principale de cette fonction est de créer trois nouveaux processus enfants, qui acceptent les connexions de trois manières : TCP/IP, canaux nommés et mémoire partagée. Dans des circonstances normales, les clients utilisent TCP/IP (socket) pour se connecter au serveur MySQL, qui constitue la méthode de communication la plus flexible. Cependant, dans l’environnement applicatif des logiciels embarqués, ces deux dernières méthodes de communication doivent être utilisées.

• Fonction handle_connections_methods() simplifiée :

static void handle_connections_methods()
{
  mysql_mutex_lock(&LOCK_thread_count);
  mysql_cond_init(key_COND_handler_count, &COND_handler_count, NULL);
  handler_count=0;
  handler_count++;
  mysql_thread_create(key_thread_handle_con_namedpipes, &hThread, &connection_attrib, handle_connections_namedpipes, 0))；
  handler_count++;
  mysql_thread_create(key_thread_handle_con_sockets, &hThread, &connection_attrib, handle_connections_sockets_thread, 0))；
  handler_count++;
  mysql_thread_create(key_thread_handle_con_sharedmem, &hThread, &connection_attrib, handle_connections_shared_memory, 0))
  while (handler_count > 0)
    mysql_cond_wait(&COND_handler_count, &LOCK_thread_count);
  mysql_mutex_unlock(&LOCK_thread_count);
}

Après avoir créé 3 nouveaux threads, la fonction handle_connectins_methods() entre dans une longue boucle de temps jusqu'à ce que les trois threads de connexion sortent. Ici, je regarde principalement le thread de connexion socket. Notre objet de recherche est ce handle_connections_sockets_thread. Une fois que ce thread s'est initialisé, il appelle directement la fonction handle_connections_sockets();

handle_connections_sockets() utilise select() pour appeler le port d'écoute de mysqld, puis attend la connexion client. Après la connexion d'un client, une variable de type THD sera créée dans cette fonction. Cette variable est un "papillon social", depuis l'établissement de la connexion, jusqu'à l'analyse de la syntaxe SQL, l'exécution de la requête, le retour du résultat, etc. Cette variable est toujours là, et bref c'est une variable très importante.

Il existe également la structure struct st_vio, qui est une station de transfert de commandes. Une structure de type vio est également définie dans le THD « Social Butterfly ». La fonction de cette structure est de lire le contenu de la communication depuis la socket, puis d'attribuer sa valeur à la variable vio de THD. Le type VIO décrit une requête en détail, y compris le contenu de la requête, l'heure, l'adresse de socket de la requête, etc. Ce qui se passe ensuite est de transmettre ce « papillon social » au thread de service, et create_thread_to_handle_connection() implémente cette fonction.

• Ce qui suit est le code supprimé

void create_thread_to_handle_connection(THD *thd)
{
  if (cached_thread_count > wake_thread)
  {
    mysql_cond_signal(&COND_thread_cache);
  }
  else
  {
    mysql_thread_create(key_thread_one_connection, &thd->real_id, &connection_attrib, handle_one_connection, (void*) thd)))；    
  }
}

Cette fonction vérifiera s'il y a des threads de cache inactifs (MySQL n'interrompra pas le service le thread après l'ouverture de la connexion est détruit immédiatement et mis en cache à la place). S'il y en a un, utilisez le thread de cache. Sinon, créez un nouveau thread pour servir la connexion. À ce stade, une connexion est entrée dans le thread de service, et le thread de connexion revient et continue d'attendre la connexion.

Le contenu suivant est entièrement implémenté dans le fil de discussion du service. Il y a une trace de code très détaillée dans « Compréhension approfondie de MySQL ». J'ai joint la séquence d'appel de fonction pour référence.

handle_one_connection()
mysql_thread_create()
handle_one_connection()
do_handle_one_connection()
init_new_connection_thread()
init_new_connection_handler_thread()
do_command()
dispatch_command()
mysql_parse()
mysql_execuate_command()

Ce qui précède est l'analyse du processus de connexion au serveur MySQL. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !