The server shutdown process takes place as follows:
The shutdown process is initiated.
This can occur initiated several ways. For example, a user
SHUTDOWN privilege can
execute a mysqladmin shutdown command.
mysqladmin can be used on any platform
supported by MySQL. Other operating system-specific shutdown
initiation methods are possible as well: The server shuts down
on Unix when it receives a
A server running as a service on Windows shuts down when the
services manager tells it to.
The server creates a shutdown thread if necessary.
Depending on how shutdown was initiated, the server might
create a thread to handle the shutdown process. If shutdown
was requested by a client, a shutdown thread is created. If
shutdown is the result of receiving a
SIGTERM signal, the signal thread might
handle shutdown itself, or it might create a separate thread
to do so. If the server tries to create a shutdown thread and
cannot (for example, if memory is exhausted), it issues a
diagnostic message that appears in the error log:
Error: Can't create thread to kill server
The server stops accepting new connections.
To prevent new activity from being initiated during shutdown, the server stops accepting new client connections by closing the handlers for the network interfaces to which it normally listens for connections: the TCP/IP port, the Unix socket file, the Windows named pipe, and shared memory on Windows.
The server terminates current activity.
For each thread associated with a client connection, the
server breaks the connection to the client and marks the
thread as killed. Threads die when they notice that they are
so marked. Threads for idle connections die quickly. Threads
that currently are processing statements check their state
periodically and take longer to die. For additional
information about thread termination, see
KILL Syntax, in particular for the instructions
REPAIR TABLE or
OPTIMIZE TABLE operations on
For threads that have an open transaction, the transaction is
rolled back. Note that if a thread is updating a
nontransactional table, an operation such as a multiple-row
INSERT may leave the table
partially updated because the operation can terminate before
If the server is a master replication server, it treats threads associated with currently connected slaves like other client threads. That is, each one is marked as killed and exits when it next checks its state.
If the server is a slave replication server, it stops the I/O
and SQL threads, if they are active, before marking client
threads as killed. The SQL thread is permitted to finish its
current statement (to avoid causing replication problems), and
then stops. In MySQL 5.0.80 and earlier, if the SQL thread was
in the middle of a transaction at this point, the transaction
was rolled back; in MySQL 5.0.81 and later, the server waits
until the current replication event group (if any) has
finished executing, or until the user issues a
KILL QUERY or
CONNECTION statement. See also
STOP SLAVE Syntax.
If the slave is updating a nontransactional table when it is forcibly killed, the slave's data may become inconsistent with the master.
The server shuts down or closes storage engines.
At this stage, the server flushes the table cache and closes all open tables.
Each storage engine performs any actions necessary for tables
that it manages. For example,
flushes any pending index writes for a table.
InnoDB flushes its buffer pool to disk
(starting from 5.0.5: unless
innodb_fast_shutdown is 2),
writes the current LSN to the tablespace, and terminates its
own internal threads.
The server exits.