1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/*
Copyright (c) 2013, 2025, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef CONNECTION_HANDLER_IMPL_INCLUDED
#define CONNECTION_HANDLER_IMPL_INCLUDED
#include <list>
#include "mysql/psi/mysql_cond.h" // mysql_cond_t
#include "mysql/psi/mysql_mutex.h" // mysql_mutex_t
#include "sql/conn_handler/connection_handler.h" // Connection_handler
class Channel_info;
class THD;
/**
This class represents the connection handling functionality
that each connection is being handled in a single thread
*/
class Per_thread_connection_handler : public Connection_handler {
Per_thread_connection_handler(const Per_thread_connection_handler &);
Per_thread_connection_handler &operator=(
const Per_thread_connection_handler &);
/**
Check if idle threads to handle connection in
thread cache. If so enqueue the new connection
to be picked by the idle thread in thread cache.
@retval false if idle pthread was found, else true.
*/
bool check_idle_thread_and_enqueue_connection(Channel_info *channel_info);
/**
List of pending channel info objects to be picked by idle
threads. Protected by LOCK_thread_cache.
*/
static std::list<Channel_info *> *waiting_channel_info_list;
static mysql_mutex_t LOCK_thread_cache;
static mysql_cond_t COND_thread_cache;
static mysql_cond_t COND_flush_thread_cache;
public:
// Status variables related to Per_thread_connection_handler
static ulong blocked_pthread_count; // Protected by LOCK_thread_cache.
static ulong slow_launch_threads;
static bool shrink_cache; // Protected by LOCK_thread_cache
// System variable
static ulong max_blocked_pthreads;
static void init();
static void destroy();
/**
Wake blocked pthreads and wait until they have terminated.
*/
static void kill_blocked_pthreads();
/**
Block until a new connection arrives.
*/
static Channel_info *block_until_new_connection();
/**
Modify the thread cache size.
@param thread_cache_size size of thread cache.
*/
static void modify_thread_cache_size(const ulong thread_cache_size);
Per_thread_connection_handler() = default;
~Per_thread_connection_handler() override = default;
protected:
bool add_connection(Channel_info *channel_info) override;
uint get_max_threads() const override;
};
/**
This class represents the connection handling functionality
of all connections being handled in a single worker thread.
*/
class One_thread_connection_handler : public Connection_handler {
One_thread_connection_handler(const One_thread_connection_handler &);
One_thread_connection_handler &operator=(
const One_thread_connection_handler &);
public:
One_thread_connection_handler() = default;
~One_thread_connection_handler() override = default;
protected:
bool add_connection(Channel_info *channel_info) override;
uint get_max_threads() const override { return 1; }
};
#endif // CONNECTION_HANDLER_IMPL_INCLUDED
|
