database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-01 03:47:19 +03:00
Code Activity

Bug#38522: 5 seconds delay when closing application using embedded server

Browse Source 
The problem here is that embedded server starts handle_thread manager 
thread  on mysql_library_init() does not stop it on mysql_library_end().
At shutdown, my_thread_global_end() waits for thread count to become 0,
but since we did not stop the thread it will give up after 5 seconds.
             
Solution is to move shutdown for handle_manager thread from kill_server()
(mysqld specific) to clean_up() that is used by both embedded and mysqld.
            
This patch also contains some refactorings - to avoid duplicate code,
start_handle_manager() and stop_handle_manager() functions are introduced.
Unused variables are eliminated. handle_manager does not rely on global
variable abort_loop anymore to stop (abort_loop is not set for embedded).
            
Note: Specifically on Windows and when using DBUG version of libmysqld, 
the complete solution requires removing obsolete code my_thread_init() 
from my_thread_var(). This has a side effect that a DBUG statement 
after my_thread_end() can cause thread counter to be incremented, and 
embedded will hang for some seconds. Or worse, my_thread_init() will 
crash if critical sections have been deleted by the global cleanup 
routine that runs in a different thread. 

This patch also fixes and revert prior changes for Bug#38293 
"Libmysqld crash in mysql_library_init if language file missing".

Root cause of the crash observed in Bug#38293  was bug in my_thread_init() 
described above
This commit is contained in:
Vladislav Vaintroub
2008-12-04 19:41:53 +01:00
parent 9e91c8d6c2
commit 4dfbf2ec93
11 changed files with 56 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
sql/sql_manager.cc
View File

@ -23,8 +23,9 @@
#include "mysql_priv.h"
ulong volatile manager_status;
bool volatile manager_thread_in_use;
static bool volatile manager_thread_in_use;
static bool abort_manager;
pthread_t manager_thread;
pthread_mutex_t LOCK_manager;
@ -63,7 +64,6 @@ bool mysql_manager_submit(void (*action)())
pthread_handler_t handle_manager(void *arg __attribute__((unused)))
{
int error = 0;
ulong status;
struct timespec abstime;
bool reset_flush_time = TRUE;
struct handler_cb *cb= NULL;
@ -72,7 +72,6 @@ pthread_handler_t handle_manager(void *arg __attribute__((unused)))
pthread_detach_this_thread();
manager_thread = pthread_self();
manager_status = 0;
manager_thread_in_use = 1;
for (;;)
@ -87,16 +86,14 @@ pthread_handler_t handle_manager(void *arg __attribute__((unused)))
set_timespec(abstime, flush_time);
reset_flush_time = FALSE;
}
while (!manager_status && (!error || error == EINTR) && !abort_loop)
while ((!error || error == EINTR) && !abort_manager)
error= pthread_cond_timedwait(&COND_manager, &LOCK_manager, &abstime);
}
else
{
while (!manager_status && (!error || error == EINTR) && !abort_loop)
while ((!error || error == EINTR) && !abort_manager)
error= pthread_cond_wait(&COND_manager, &LOCK_manager);
}
status = manager_status;
manager_status = 0;
if (cb == NULL)
{
cb= cb_list;
@ -104,7 +101,7 @@ pthread_handler_t handle_manager(void *arg __attribute__((unused)))
}
pthread_mutex_unlock(&LOCK_manager);
if (abort_loop)
if (abort_manager)
break;
if (error == ETIMEDOUT || error == ETIME)
@ -121,11 +118,42 @@ pthread_handler_t handle_manager(void *arg __attribute__((unused)))
my_free((uchar*)cb, MYF(0));
cb= next;
}
if (status)
DBUG_PRINT("error", ("manager did not handle something: %lx", status));
}
manager_thread_in_use = 0;
DBUG_LEAVE; // Can't use DBUG_RETURN after my_thread_end
my_thread_end();
DBUG_RETURN(NULL);
return (NULL);
}
/* Start handle manager thread */
void start_handle_manager()
{
DBUG_ENTER("start_handle_manager");
abort_manager = false;
if (flush_time && flush_time != ~(ulong) 0L)
{
pthread_t hThread;
if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
sql_print_warning("Can't create handle_manager thread");
}
DBUG_VOID_RETURN;
}
/* Initiate shutdown of handle manager thread */
void stop_handle_manager()
{
DBUG_ENTER("stop_handle_manager");
abort_manager = true;
pthread_mutex_lock(&LOCK_manager);
if (manager_thread_in_use)
{
DBUG_PRINT("quit", ("initiate shutdown of handle manager thread: 0x%lx",
(ulong)manager_thread));
pthread_cond_signal(&COND_manager);
}
pthread_mutex_unlock(&LOCK_manager);
DBUG_VOID_RETURN;
}