CN112817933A - Management method and device for elastic database connection pool - Google Patents
Management method and device for elastic database connection pool Download PDFInfo
- Publication number
- CN112817933A CN112817933A CN202011623109.2A CN202011623109A CN112817933A CN 112817933 A CN112817933 A CN 112817933A CN 202011623109 A CN202011623109 A CN 202011623109A CN 112817933 A CN112817933 A CN 112817933A
- Authority
- CN
- China
- Prior art keywords
- connection
- database
- pool
- request
- queue
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000007726 management method Methods 0.000 title claims abstract description 18
- 238000000034 method Methods 0.000 claims description 27
- 238000012545 processing Methods 0.000 claims description 13
- 230000009471 action Effects 0.000 claims description 12
- 230000004044 response Effects 0.000 claims description 3
- 238000010586 diagram Methods 0.000 description 9
- 238000004590 computer program Methods 0.000 description 7
- 230000008569 process Effects 0.000 description 7
- 230000006870 function Effects 0.000 description 5
- 239000002699 waste material Substances 0.000 description 5
- 230000002159 abnormal effect Effects 0.000 description 4
- 230000007547 defect Effects 0.000 description 4
- 238000012544 monitoring process Methods 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 230000006378 damage Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000004891 communication Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 230000004083 survival effect Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/21—Design, administration or maintenance of databases
- G06F16/211—Schema design and management
- G06F16/212—Schema design and management with details for data modelling support
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/25—Integrating or interfacing systems involving database management systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
- G06F9/5022—Mechanisms to release resources
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/50—Indexing scheme relating to G06F9/50
- G06F2209/5011—Pool
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/50—Indexing scheme relating to G06F9/50
- G06F2209/5018—Thread allocation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a management method and a device of an elastic database connection pool, comprising the following steps: creating a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection number is a minimum connection number parameter set during creation; responding to the database connection request, and returning the database connection stored at the top end of the queue if the available connection exists in the connection pool; the connection returned by the connection pool is saved in std: _ unique _ ptr. The invention adopts queue storage database connection and simultaneously adopts an intelligent pointer mode based on C + +11 standard to wrap the database connection, thereby reducing handle leakage caused by errors of users.
Description
Technical Field
The invention belongs to the technical field of database management, and particularly relates to a management method of an elastic database connection pool and a management device of the elastic database connection pool.
Background
A database connection (database connection) is a communication link between a database server and a client. The client sends the command and receives the result returned by the server through the database connection.
Typical application programs need to create and maintain database connections of themselves, the simultaneous use of the same connection in the case of multithreading may cause abnormal database access, if each thread creates a connection of itself, resource waste and efficiency reduction may be caused, meanwhile, the maximum database connection number of the commercial database is provided according to a purchase scheme of a user, and creating too many database connections may cause that the database cannot accept new connection requests, thereby causing a business problem.
The management of database connections can significantly affect the scalability and robustness of the entire application program, and affect the performance index of the program. The database connection pool is proposed to solve this problem.
The database connection pool is responsible for allocating, managing and releasing database connections, which allows an application to reuse one existing database connection instead of reestablishing one; database connections with idle times exceeding the maximum idle time are released to avoid database connection misses caused by not releasing the database connections. The technology can obviously improve the performance of database operation.
In the prior art, a management method of a database connection pool includes:
scheme 1: the patent publication No. CN111177203A discloses a method, a server and a storage medium for dynamically adjusting the size of a database connection pool; the method comprises the steps of setting the minimum connection number, the maximum connection number and the total connection number of a database connection pool; acquiring a connection requirement value of a client, judging whether the connection requirement value is less than or equal to the maximum connection quantity, if so, issuing connection to the client, otherwise, acquiring the waiting time of the connection request exceeding the maximum connection quantity, if the abnormal triggering time value is reached and no response is obtained, amplifying the maximum connection quantity, and issuing the new connection to the client; and when the survival time of the newly-built connection reaches the destruction triggering time value and the server does not receive a new connection request, deleting the newly-built connection and initializing the maximum connection quantity. The invention can automatically expand the maximum connection number of the connection pool, avoid abnormal connection acquisition caused by long-time waiting of the connection request, and simultaneously can automatically delete newly-built connections which are not used for a long time and release resources.
Scheme 2: application publication No.: a method for controlling a database connection pool of CN103605571A, the method comprising: normalizing thread priority; judging whether the current connection pool is empty, if the connection pool is not empty, taking out the first data connection, setting the current state as busy, and returning to the data connection; if the connection pool is empty, judging whether the number of unreturned data connections in the current use of the external program reaches the maximum number of connections in the connection pool, if not, increasing the data connections, adding the current database connection pool, and returning to the first data connection of the database connection pool; and if the number of the unreturned data connections in the current external program use reaches the maximum number of connections in the connection pool, setting the priority of the current thread, acquiring the current time as the first time, circularly judging whether the current connection pool is empty, and enabling the database connection pool to enter a waiting state. Under the environment of high concurrency and multiple data sources, the data access performance is effectively improved.
Scheme 3: application publication No.: CN106484882A discloses a method and an apparatus for managing a database connection pool, which are used to avoid waste of connection and improve the management efficiency of the database connection pool. The embodiment of the invention provides a management method of a database connection pool, which comprises the following steps: receiving a database access request sent by a first thread currently called by an application program; selecting available connection from a database connection pool according to the database access request, wherein the database connection pool is a common connection pool created for a plurality of threads needing to be called by the application program; and allocating the selected available connection to the first thread for use, and performing application data operation by the first thread by using the available connection.
The prior art scheme 1 has the following defects: the invention can connect the maximum connection number of the pool according to the conditions of the maximum, the minimum and the current connection number of the current connection pool. However, in this scheme, when the number of existing connections is smaller than the maximum number of connections, the number of connections is not reduced, which results in waste of connections.
The prior art scheme 2 has the following defects: the method returns the connection if the connection pool is not empty when the program requests the connection, and the program is busy and waits until the database connection is available if the connection pool is empty and the current connection number is less than the maximum connection number. According to the scheme, a busy waiting scheme is adopted, CPU resources are circularly judged and consumed, and meanwhile, the scheme does not support the resource waste caused by destroying the connection when the database connection is idle for a long time.
The prior art scheme 3 has the following defects: the invention returns a connection if the connection pool is not empty when the program requests a connection, and returns a failure if empty. According to the scheme, when the database connection pool is empty, failure is directly returned, a program is forced to process a failure flow, complexity is increased, and meanwhile, the scheme does not support resource waste caused by connection destruction when the database connection is idle for a long time.
In view of the above, there is a need for a new method for managing a database connection pool, which overcomes the above drawbacks.
Disclosure of Invention
The invention aims to overcome the defects in the prior art, provides a management method of a connection pool of an elastic database, and solves the problem that the connection quantity in the prior art cannot be automatically recovered.
In order to solve the above technical problem, the present invention provides a method for managing a connection pool of an elastic database, comprising:
creating a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection number is a minimum connection number parameter set during creation;
responding to the database connection request, and returning the database connection stored at the top end of the queue if the available connection exists in the connection pool;
and storing the connection returned by the connection pool in an intelligent pointer std:unique _ ptr.
Further, when the database connection is stored in the queue, simultaneously recording the database connection storage time, judging whether the difference value between the storage time of the database connection at the top end of the queue and the current time is larger than a connection idle time parameter set during creation, if so, closing the connection and removing the queue; otherwise, waiting to the next time point and continuing to repeat the judgment action.
Further, when responding to the database connection request, if there is no available connection in the connection pool, determining whether the request timeout parameter set during creation is 0, and if the request timeout parameter is 0, waiting until there is a free connection in the connection pool, acquiring a connection, and returning.
Further, the method also comprises the following steps:
and if the request timeout time parameter is not 0, waiting until timeout or idle connection exists in the thread pool, trying to acquire the connection, and if the connection can be acquired, acquiring the connection and returning.
Further, the method also comprises the following steps:
if the connection cannot be acquired, acquiring processing parameters after the request is overtime: if the processing parameter is 0 after the request is overtime, the exception is thrown out; if the processing parameter is 1 after the request is overtime, trying to establish and acquire a temporary connection, and throwing an exception when the establishment fails; and if the processing parameter is 2 after the request is overtime, trying to establish and acquire the temporary connection, and waiting for the next overtime time when the establishment fails.
Correspondingly, the invention also provides a management device of the elastic database connection pool, which comprises the following steps:
the connection establishing module is used for establishing a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection quantity is a minimum connection quantity parameter set during establishment;
the connection acquisition module is used for responding to the database connection request, and returning the database connection stored at the top end of the queue if the connection pool has available connection;
and the connection storage module is used for storing the connection returned by the connection pool in the intelligent pointer std:: unique _ ptr.
Compared with the prior art, the invention has the following beneficial effects: the invention adopts queue storage database connection, simultaneously monitors the space time of the connection of the queue head, and closes the connection and removes the queue if the idle time is more than the idle time of the idle _ time connection parameter during the creation. Meanwhile, the database connection is wrapped in an intelligent pointer mode based on the C + +11 standard, so that handle leakage caused by errors of a user is reduced.
Drawings
FIG. 1 is a schematic diagram of a database connection pool creation process;
fig. 2 is a flow chart illustrating a request connection.
Detailed Description
The invention is further described below with reference to the accompanying drawings. The following examples are only for illustrating the technical solutions of the present invention more clearly, and the protection scope of the present invention is not limited thereby.
Example 1
The invention relates to a management method of a connection pool of an elastic database, which comprises the following steps:
step 1, creating a database connection pool:
the creation process of the database connection pool is shown in fig. 1, and specifically includes the following processes:
the database connection pool initializes the database connection upon initialization based on user-provided information, the user-entered information being shown in table 1. These parameters are provided at the time of creation of the database connection pool, where all connections share the same parameters.
TABLE 1 input information to initialize database connections
The interior of the database connection pool adopts a queue as a data container for storing connection, and the queue is characterized in that first-in first-out is carried out, and the database connection pool thread creates database connection until the minimum connection number is reached and stores the database connection number into the queue.
When the database is connected and stored in the queue, the storage time is recorded, then the monitoring thread is started, the monitoring thread continuously compares the connection storage time with the current time, and the difference value of the comparison is the idle time. And then the monitoring thread judges whether the idle time of the database connection at the top of the queue (the first queue head) is greater than the idle time of the idle _ time connection parameter during creation, if so, the connection is closed and the queue is removed, otherwise, the thread waits for the next time point to continue to repeat the judgment action.
At initialization, a certain number of database connections are created and put into the connection pool, and the number of the database connections is limited by the parameter of the minimum number of connections. The connection pool will always guarantee at least so many connections, whether or not these database connections are used.
Step 2, request connection
The process is shown in fig. 2 and comprises the following steps:
when a program application database connection request is received, a connection pool firstly judges whether available connection exists (a connection pool queue is not empty, if the number of current connections in the empty connection pool is smaller than the maximum number of connections, a new connection is created and added into the queue, and the queue is not empty at the moment), if available connection exists, the connection is returned to the top end of the queue, otherwise, the next action is carried out through preset parameters.
Action 1, when time _ out is 0, the program waits until there is free connection in the thread pool, acquires connection and returns;
action 2, when the time _ out is not 0, the program waits until timeout or idle connection exists in the thread pool, tries to acquire connection, if connection cannot be acquired (if timeout happens, the connection pool is empty, and connection cannot be acquired), the sub-action is executed, otherwise, connection is acquired and returned;
sub-action 1, throwing an exception when the time _ out _ handle is 0;
a sub-action 2, when the time _ out _ handle is 1, trying to establish and acquire a temporary connection, and throwing an exception when the establishment fails;
sub-action 3, when time _ out _ handle is 2, the temporary connection is tried to be created and acquired, and action 2 is executed when the creation fails.
In summary, four modes are connected to the program acquisition, and the operating logic executed is as follows:
mode 1: action 1;
mode 2, action 2, sub-action 1;
mode 3, action 2, sub-action 2;
mode 4: action 2, sub-action 3.
Step 3, releasing the connection
When the program acquires the connection and releases the connection after the connection is used, the implementation scheme is as follows: when the connection is returned to the available database of the program, the connection is wrapped by the intelligent pointer, so that the connection cannot be copied, and the connection is prevented from being persistently stored by the program. Meanwhile, when the intelligent pointer is automatically destroyed, the connection regression connection pool is released, and handle leakage caused by the fact that the user forgets to return the connection is prevented.
In the embodiment of the present invention, the specific processing procedure is as follows: saving connections returned from the connection pool in
The unique _ ptr cannot be copied, and the life cycle of the unique _ ptr only exists in the visual range of the C + + grammar. And after the std is destructed, the destructor automatically executes a release method to return the saved connection to a connection pool, thereby preventing the connection from leaking.
Unique _ ptr is a type of smart pointer, introduced in C + +11, that takes hold of and manages another object through a pointer, and releases the object when the unique _ ptr leaves the scope.
The maximum number of database connections in the connection pool defines the maximum number of connections that the connection pool can occupy, and if the database connections requested by the program are greater than the current number of connection pools but less than the maximum number of database connections, the connection pool will create new connections for use. These database connections greater than the minimum number of connections will not be released immediately after use, it will be put into the connection pool waiting for reuse or released after idle timeout. When the number of connections requested by an application from the connection pool exceeds the maximum number of connections, the requests are added to the wait queue until a connection is available.
The invention establishes and manages database connection through configuration parameters, meets the requirement of program request connection through different logics executed by the parameters, and automatically manages the connection resources so that the program does not need to concern about the matters of resource application and release.
The invention has the beneficial effects that:
1) the automatic management mode of the database connection pool is used for balancing the response time and the resource occupation;
2) the database connection obtaining mode can obtain connection in different modes through a parameter program;
3) the automatic release function of the database connection, the program does not need to care about the release action, and the resource leakage is prevented under the abnormal condition.
Compared with the existing database connection pool scheme, the method realizes the automatic management of the database connection resources, including automatic application when the connection is insufficient, automatic release when no request is available for a long time and automatic return when a program is used. The scheme ensures that a programmer does not need to concern and manage the application and the release of resources when using the invention, thereby reducing the workload and leading the programmer to be more concerned with the business logic.
Example 2
The invention relates to a management device of an elastic database connection pool, which comprises:
the connection establishing module is used for establishing a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection quantity is a minimum connection quantity parameter set during establishment;
the connection acquisition module is used for responding to the database connection request, and returning the database connection stored at the top end of the queue if the connection pool has available connection;
and the connection storage module is used for storing the connection returned by the connection pool in the intelligent pointer std:: unique _ ptr.
The specific implementation process of each module of the device of the invention refers to the specific implementation steps of the method in the embodiment 1.
As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The above description is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, several modifications and variations can be made without departing from the technical principle of the present invention, and these modifications and variations should also be regarded as the protection scope of the present invention.
Claims (6)
1. A management method for a connection pool of an elastic database is characterized by comprising the following steps:
creating a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection number is a minimum connection number parameter set during creation;
responding to the database connection request, and returning the database connection stored at the top end of the queue if the available connection exists in the connection pool;
and storing the database connection returned by the connection pool in the intelligent pointer std:unique _ ptr.
2. The method as claimed in claim 1, wherein when the database connection is stored in the queue, the database connection storage time is recorded, whether the difference between the storage time of the database connection at the top of the queue and the current time is greater than the connection idle time parameter set during creation is judged, and if yes, the connection is closed and the queue is removed; otherwise, waiting to the next time point and continuing to repeat the judgment action.
3. The method as claimed in claim 1, wherein in response to the database connection request, if there is no connection available in the connection pool, determining whether the request timeout parameter set at the time of creation is 0, and if the request timeout parameter is 0, waiting until there is a free connection in the connection pool, acquiring a connection and returning.
4. The method for managing a connection pool of a resilient database as claimed in claim 3, further comprising:
and if the request timeout time parameter is not 0, waiting until timeout or idle connection exists in the thread pool, trying to acquire the connection, and if the connection can be acquired, acquiring the connection and returning.
5. The method for managing connection pool of elastic database as claimed in claim 4, further comprising:
if the connection cannot be acquired, acquiring processing parameters after the request is overtime: if the processing parameter is 0 after the request is overtime, the exception is thrown out; if the processing parameter is 1 after the request is overtime, trying to establish and acquire a temporary connection, and throwing an exception when the establishment fails; and if the processing parameter is 2 after the request is overtime, trying to establish and acquire the temporary connection, and waiting for the next overtime time when the establishment fails.
6. A management device for a connection pool of an elastic database is characterized by comprising:
the connection establishing module is used for establishing a plurality of database connections during initialization and storing the database connections into a queue of a connection pool, wherein the database connection quantity is a minimum connection quantity parameter set during establishment;
the connection acquisition module is used for responding to the database connection request, and returning the database connection stored at the top end of the queue if the connection pool has available connection;
and the connection storage module is used for storing the database connection returned by the connection pool in the intelligent pointer std:: unique _ ptr.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011623109.2A CN112817933A (en) | 2020-12-30 | 2020-12-30 | Management method and device for elastic database connection pool |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011623109.2A CN112817933A (en) | 2020-12-30 | 2020-12-30 | Management method and device for elastic database connection pool |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112817933A true CN112817933A (en) | 2021-05-18 |
Family
ID=75854909
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011623109.2A Pending CN112817933A (en) | 2020-12-30 | 2020-12-30 | Management method and device for elastic database connection pool |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112817933A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114675908A (en) * | 2022-05-27 | 2022-06-28 | 武汉中科通达高新技术股份有限公司 | Service data processing system, method, computer device and storage medium |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1622528A (en) * | 2003-11-26 | 2005-06-01 | 国际商业机器公司 | Efficient connection pool management system and method |
| US20050149809A1 (en) * | 2003-12-10 | 2005-07-07 | International Business Machines Corporation | Real time determination of application problems, using a lightweight diagnostic tracer |
| CN102708175A (en) * | 2012-05-07 | 2012-10-03 | 北京航空航天大学 | Automatic reconnection method and automatic reconnection device for contingency interrupt of database connection |
| CN103559204A (en) * | 2013-10-08 | 2014-02-05 | 北京奇虎科技有限公司 | Database operation request processing method, unit and system |
| US20150026405A1 (en) * | 2013-06-06 | 2015-01-22 | Oracle International Corporation | System and method for providing a second level connection cache for use with a database environment |
| CN104484452A (en) * | 2014-12-25 | 2015-04-01 | 广东电子工业研究院有限公司 | Connection reusing and unified management and control method of multi-element isomerism relation database |
| CN106469052A (en) * | 2015-08-20 | 2017-03-01 | 张平 | A kind of strange land plant data storehouse synchronous method for electronics work-ticket machine |
| CN111177203A (en) * | 2019-12-18 | 2020-05-19 | 中国平安财产保险股份有限公司 | Method, server and storage medium for dynamically adjusting size of database connection pool |
-
2020
- 2020-12-30 CN CN202011623109.2A patent/CN112817933A/en active Pending
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1622528A (en) * | 2003-11-26 | 2005-06-01 | 国际商业机器公司 | Efficient connection pool management system and method |
| US20050149809A1 (en) * | 2003-12-10 | 2005-07-07 | International Business Machines Corporation | Real time determination of application problems, using a lightweight diagnostic tracer |
| CN102708175A (en) * | 2012-05-07 | 2012-10-03 | 北京航空航天大学 | Automatic reconnection method and automatic reconnection device for contingency interrupt of database connection |
| US20150026405A1 (en) * | 2013-06-06 | 2015-01-22 | Oracle International Corporation | System and method for providing a second level connection cache for use with a database environment |
| CN103559204A (en) * | 2013-10-08 | 2014-02-05 | 北京奇虎科技有限公司 | Database operation request processing method, unit and system |
| CN104484452A (en) * | 2014-12-25 | 2015-04-01 | 广东电子工业研究院有限公司 | Connection reusing and unified management and control method of multi-element isomerism relation database |
| CN106469052A (en) * | 2015-08-20 | 2017-03-01 | 张平 | A kind of strange land plant data storehouse synchronous method for electronics work-ticket machine |
| CN111177203A (en) * | 2019-12-18 | 2020-05-19 | 中国平安财产保险股份有限公司 | Method, server and storage medium for dynamically adjusting size of database connection pool |
Non-Patent Citations (1)
| Title |
|---|
| 梁伟: "《从零开始学C++》", 北京：中国铁道出版社, pages: 346 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114675908A (en) * | 2022-05-27 | 2022-06-28 | 武汉中科通达高新技术股份有限公司 | Service data processing system, method, computer device and storage medium |
| CN114675908B (en) * | 2022-05-27 | 2022-08-26 | 武汉中科通达高新技术股份有限公司 | Service data processing system, method, computer device and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9977689B2 (en) | Dynamic scaling of management infrastructure in virtual environments | |
| CN108595282A (en) | A kind of implementation method of high concurrent message queue | |
| CN102063338B (en) | Method and device for requesting exclusive resource | |
| CN109710416B (en) | Resource scheduling method and device | |
| US20090043873A1 (en) | Methods and Apparatus for Restoring a Node State | |
| CN111427751B (en) | Method and system for processing business based on asynchronous processing mechanism | |
| CN106547612A (en) | A kind of multi-task processing method and device | |
| US10075326B2 (en) | Monitoring file system operations between a client computer and a file server | |
| CN109558244A (en) | Junk information recovery method, device, equipment and computer readable storage medium | |
| WO2018196462A1 (en) | Resource scheduling apparatus, resource scheduling system and resource scheduling method | |
| CN112817933A (en) | Management method and device for elastic database connection pool | |
| CN102426539B (en) | Timer task automatic processing method and system | |
| US20050262304A1 (en) | Systems and methods for passivation of cached objects in transaction | |
| US20090187614A1 (en) | Managing Dynamically Allocated Memory in a Computer System | |
| CN112363812B (en) | Database connection queue management method based on task classification and storage medium | |
| US20180121350A1 (en) | Working set adjustment in a managed environment | |
| CN109766131A (en) | The system and method for the intelligent automatic upgrading of software is realized based on multithreading | |
| CN111708618A (en) | Processing method and device based on Java multithreading | |
| US20050262305A1 (en) | Systems and methods for cache and pool initialization on demand | |
| CN109426563B (en) | Process management method and device | |
| WO2022151766A1 (en) | Io request pipeline processing device, method and system, and storage medium | |
| US8984336B1 (en) | Systems and methods for performing first failure data captures | |
| CN111225007A (en) | Database connection method, device and system | |
| CN111090627B (en) | Log storage method and device based on pooling, computer equipment and storage medium | |
| CN114157717A (en) | Micro-service dynamic current limiting system and method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |