游戏服务器之mysql句柄连接池

最新推荐文章于 2023-11-29 22:44:42 发布
最新推荐文章于 2023-11-29 22:44:42 发布
阅读量444 收藏
点赞数
分类专栏： 数据库

mysql连接使用封装原理是建立mysql连接句柄池。mysql连接句柄池在初始化时会根据放入的连接地址读取所有的表(建立表对象及其相关字段)和初始化一个mysql连接句柄。mysql连接句柄池可根据哈希和使用标识获取没有标识使用的句柄。


设计上：

（1）封装mysql连接到mysql连接句柄。mysql连接句柄由句柄管理器管理(加入和读取要加读写锁)。

（2）加载连接的表及其表的字段到表对象。表对象由表结构管理器管理（加入和读取要加读写锁）。实现orm的检查功能。

（3）封装条件查询。实现简化和安全使用字段和条件组成sql。

（4）封装结果集。实现简化获取执行sql结果。


数据结构：

（1）表结构管理器 

std::vector<mysql_table_manager *> tm;  //数据库表管理器 数组

获取表如

mysql_table* table  = this->pool->tm[this->_hashcode]->getTableByName(tablename);//pool 为句柄连接池


（2）句柄管理器

std::vector<mysql_handle_manager *> mhm;//mysql句柄数组，由哈希获取句柄管理者，再遍历获取没有标识使用的句柄。根据实际应用情况分散hashcode 的桶上的连接对象 可以有效减少多线程使用mysql句柄的竞争。


目录：

1、mysql句柄池

（1）句柄池初始化mysql句柄池

（2）加载连接地址

（2-1）加载表格

（3）获取句柄

2、条件查询

(1)条件查询封装

(2)执行sql

(3)查询使用实例


内容：

1、mysql句柄池

每个mysql句柄就是个mysql连接。句柄池会用哈希结构存储mysql句柄，按哈希结构存储mysql连接上的所有表结构。

（1）句柄池初始化mysql句柄池

/**
 * \description 构造函数
 * \param max_hash 支持最大的hash个数
 * \param max_handle 每个hash桶中支持的最多handle个数
 */

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mysql_handle_pool::mysql_handle_pool(int max_hash,int max_handle)//int max_hash = 3,int max_handle = 64  
  2. {  
  3.     for(int i = 0 ; i < max_hash ; i ++)  
  4.     {  
  5.         mhm.push_back(new mysql_handle_manager);  
  6.         tm.push_back(new mysql_table_manager);  
  7.     }  
  8.     _max_hash = max_hash;  
  9.     _max_handle = max_handle;  
  10.     g_log->info("Version of the mysql libs is %s" ,mysql_get_client_info());  
  11.     if(!mysql_thread_safe())  
  12.     {         
  13.         g_log->warn("The mysql libs is not thread safe...");  
  14.     }    
  15. }  

（2）加载连接地址

生成连接句柄。加载连接地址上的所有表结构。

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_handle_pool::putUrl(unsigned int hashcode,const char *url)  
  2. {  
  3.     mysql_url *mu = new mysql_url(hashcode,url);//生成连接句柄  
  4.     if(!mu)  
  5.     {  
  6.         return false;  
  7.     }  
  8.     if(!mum.addMysqlUrl(mu))  
  9.     {  
  10.         SAFE_DELETE(mu);  
  11.         return false;  
  12.     }  
  13.     mysql_handle *handle = new mysql_handle(mu,this,hashcode%_max_hash);  
  14.     if(!handle)  
  15.     {  
  16.         return false;  
  17.     }  
  18.     if(!handle->initHandle())//初始化mysql连接  
  19.     {  
  20.         SAFE_DELETE(handle);  
  21.         return false;  
  22.     }  
  23.     if(!mhm[hashcode]->addMysqlHandle(handle))  
  24.     {  
  25.         return false;  
  26.     }  
  27.     tm[hashcode]->reloadAllTables(handle->getMysql());//加载连接上的所有表格  
  28.     return true;  
  29. }  

使用实例

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mysqlPool = new mysql_handle_pool;  
  2. if(mysqlPool == NULL ||!mysqlPool->putUrl(0,g_xml_config.get_string("Global.MYSQL.Config")))  
  3. {  
  4.     g_log->error("连接数据库失败");  
  5.     return false;  
  6. }  

连接配置如： "mysql://root:123456@192.168.188.87:3306/mu"


（2-1）加载表格

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_table_manager::reloadAllTables(MYSQL *mysql_conn)  
  2. {  
  3.     MYSQL_RES* table_res = NULL;  
  4.   
  5.     if((table_res = mysql_list_tables(mysql_conn, NULL)) == NULL)//加载所有表格  
  6.     {  
  7.         g_log->error("%s:mysql_list_tables fail.", __FUNCTION__);  
  8.         g_log->error("%s:reason: %s", __FUNCTION__,mysql_error(mysql_conn));  
  9.         return false;  
  10.     }             
  11.     MYSQL_ROW row;  
  12.   
  13.     delete_all();  
  14.   
  15.     while((row=mysql_fetch_row(table_res)))  
  16.     {  
  17.         this->addNewTable(mysql_conn, row[0]);  
  18.     }  
  19.   
  20.     mysql_free_result(table_res);  
  21.     return true;  
  22. }  

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_table_manager::addNewTable(MYSQL *mysql_conn,const char *tablename)  
  2. {  
  3.     mysql_table *table = new mysql_table;  
  4.     if(!table)  
  5.     {  
  6.         return false;  
  7.     }  
  8.     strncpy(table->name,tablename,sizeof(table->name));  
  9.     table->reloadAllFields(mysql_conn , tablename);  
  10.     return addTable(table);  
  11. }  


[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool addTable(mysql_table *entry)  
  2. {  
  3.     int len = strlen(entry->name);  
  4.     for (int i = 0; i < len; i++)  
  5.     {  
  6.         entry->name[i] = ::toupper(entry->name[i]);  
  7.     }  
  8.       
  9.     bool bret = false;  
  10.     rwlock.wrlock();  
  11.     bret = add_object(entry);  
  12.     rwlock.unlock();  
  13.     return bret;  
  14. }  


加载字段

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_table::reloadAllFields(MYSQL *mysql_conn,const char *tablename)  
  2. {  
  3.     MYSQL_RES* field_res = NULL;  
  4.     field_res = mysql_list_fields(mysql_conn, tablename, NULL);  
  5.     if(!field_res)  
  6.     {  
  7.         return false;  
  8.     }  
  9.     unsigned int num_fields = mysql_num_fields(field_res);  
  10.     MYSQL_FIELD* mysql_fields = NULL;  
  11.     mysql_fields = mysql_fetch_fields(field_res);  
  12.   
  13.     for(unsigned int i=0; i<num_fields; i++)  
  14.     {  
  15.         if(!fs.addNewField(mysql_fields[i].name, mysql_fields[i].type))  
  16.         {  
  17.             mysql_free_result(field_res);  
  18.             return false;  
  19.         }  
  20.     }  
  21.   
  22.     mysql_free_result(field_res);  
  23.     return true;  
  24. }  
[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_record::addNewField(const char *fieldname, int fieldType, uint32 mask)  
  2. {  
  3.     mysql_field *entry = new mysql_field;  
  4.     if(!entry)  
  5.     {  
  6.         return false;  
  7.     }  
  8.     strncpy(entry->name,fieldname,sizeof(entry->name));  
  9.     entry->type = fieldType;  
  10.     entry->mask = mask;  
  11.     return addField(entry);  
  12. }  

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. bool mysql_record::addField(mysql_field *entry)  
  2. {  
  3.     for(unsigned int i = 0;entry->name[i]&&i < sizeof(entry->name);++i)  
  4.         entry->name[i] = (char)::toupper(entry->name[i]);  
  5.         g_log->trace("%s,%u, %s", __PRETTY_FUNCTION__, __LINE__, entry->name.c_str());  
  6.     bool bret = false;  
  7.     rwlock.wrlock();  
  8.     bret = add_object(entry);  
  9.     rwlock.unlock();  
  10.     return bret;  
  11. }  


（3）获取句柄

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mysql_handle *mysql_handle_pool::getHandle(uint32 hashcode)  
  2. {  
  3.     struct GetHandleExec :public callback<mysql_handle>  
  4.     {  
  5.         GetHandleExec():_handle(NULL)  
  6.         {  
  7.         }  
  8.         mysql_handle *_handle;  
  9.         bool invoke(mysql_handle *entry)  
  10.         {  
  11.             switch(entry->state)  
  12.             {  
  13.                 case HandleState_Valid:  
  14.                 case HandleState_Invalid:  
  15.                     {  
  16.                         if(entry->setHandle())//设置句柄  
  17.                         {  
  18.                             _handle = entry;  
  19.                             return false;  
  20.                         }  
  21.                     }  
  22.                     break;  
  23.                 case HandleState_Used:  
  24.                     {  
  25.                         entry->checkUseTime();//检查使用句柄时间  
  26.                     }  
  27.                     break;  
  28.             }  
  29.             return true;  
  30.         }  
  31.     };  
  32.     GetHandleExec exec;  
  33.         _mutex.lock();  
  34.     while(true)  
  35.     {  
  36.         mhm[hashcode%_max_hash]->traverseMysqlHandle(exec);  
  37.         if(exec._handle)  
  38.         {  
  39.                         _mutex.unlock();  
  40.             return exec._handle;  
  41.         }  
  42.         if(mhm[hashcode%_max_hash]->getSize() < _max_handle)  
  43.         {  
  44.             mysql_url *mu = mum.getMysqlUrlByID(hashcode);  
  45.             if(mu)  
  46.             {  
  47.                 mysql_handle *handle = new mysql_handle(mu,this,hashcode%_max_hash);  
  48.                 if(!handle)  
  49.                 {  
  50.                                         _mutex.unlock();  
  51.                     return NULL;  
  52.                 }  
  53.                 if(!handle->initHandle())  
  54.                 {  
  55.                     SAFE_DELETE(handle);  
  56.                                         _mutex.unlock();  
  57.                     return NULL;  
  58.                 }  
  59.                 if(!mhm[hashcode]->addMysqlHandle(handle))  
  60.                 {  
  61.                                          _mutex.unlock();  
  62.                     return NULL;  
  63.                 }  
  64.                 tm[hashcode]->reloadAllTables(handle->getMysql());  
  65.                                 _mutex.unlock();  
  66.                 return handle;  
  67.             }  
  68.         }  
  69.         thread_base::msleep(50);  
  70.     }  
  71.         _mutex.unlock();  
  72.     return exec._handle;  
  73. }  



2、条件查询

(1)条件查询封装

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mysql_record_set* mysql_handle::exeSelect(const char *tablename, mysql_record* column, mysql_record* where, mysql_record* order,   
  2.                 unsigned int limit_max,unsigned int limit_min,mysql_record* groupby, mysql_record* having)  
  3. {  
  4.     mysql_table* table  = this->pool->tm[this->_hashcode]->getTableByName(tablename);//获取表  
  5.     if (NULL == _mysql)  
  6.     {  
  7.         error_log("执行%s时_mysql指针为空",__FUNCTION__);  
  8.         return NULL;  
  9.     }  
  10.     if (NULL == table)  
  11.     {  
  12.         error_log("执行%s时table指针为空,找不到%s表",__FUNCTION__,tablename);  
  13.         return NULL;  
  14.     }  
  15.       
  16.     _select_time.now();//记录查询时间  
  17.   
  18.     std::ostringstream query_string;  
  19.   
  20.     query_string << "SELECT ";  
  21.         //所有字段名  
  22.     if(column && !column->isEmpty())  
  23.     {  
  24.         struct SqlFieldExec : public callback<mysql_field>  
  25.         {  
  26.             bool _first;  
  27.             mysql_table* _table;  
  28.             std::ostringstream &query_string;  
  29.             SqlFieldExec(mysql_table* table, std::ostringstream &query_string)  
  30.                 : _first(true), _table(table), query_string(query_string)   
  31.                 {  
  32.                 }  
  33.             bool invoke(mysql_field *entry)  
  34.             {  
  35.                 if( entry->name == "*" || _table->fs.get(entry->name))//获取字段  
  36.                 {  
  37.                     if(_first)  
  38.                     {  
  39.                         _first=false;  
  40.                     }  
  41.                     else  
  42.                     {  
  43.                         query_string <<  " , ";  
  44.                     }  
  45.   
  46.                     query_string << "`" << entry->name << "`";//字段名  
  47.                 }  
  48.                 return true;  
  49.             }  
  50.         } sfe(table, query_string);  
  51.   
  52.         column->traverseField(sfe);  
  53.     }  
  54.     else  
  55.     {  
  56.         query_string << " * ";  
  57.     }  
  58.   
  59.     query_string << "  FROM " << " `" << table->name << "` ";  
  60.     getWhere(table, query_string, where);//where 条件  
  61.     getGroupBy(table, query_string, groupby);//group   
  62.     getHaving(table, query_string, having);//having 条件  
  63.     getOrder(table, query_string, order);  
  64.   
  65.     if(limit_max)  
  66.     {  
  67.         query_string << " LIMIT " << limit_min << " , " << limit_max;  
  68.     }  
  69.   
  70.     if(execSql(query_string.str().c_str(), query_string.str().size())) //执行sql  
  71.     {  
  72.         error_log("%s", mysql_error(_mysql));  
  73.         return NULL;  
  74.     }   
  75.   
  76.     unsigned int retCount=0;  
  77.     MYSQL_RES *result=NULL;  
  78.   
  79.     result=mysql_store_result(_mysql);//一次性传送结果  
  80.     if(result==NULL)  
  81.     {  
  82.         error_log("%s", mysql_error(_mysql));  
  83.         return NULL;  
  84.     }  
  85.     retCount =mysql_num_rows(result);//获取行数  
  86.   
  87.     if(retCount==0)  
  88.     {  
  89.         mysql_free_result(result);  
  90.         return NULL;  
  91.     }  
  92.   
  93.   
  94.     MYSQL_ROW row;  
  95.     unsigned int num_field = mysql_num_fields(result);//获取结果集中的字段数  
  96.     MYSQL_FIELD* mysql_fields = NULL;  
  97.     mysql_fields = mysql_fetch_fields(result);//获取结果字段  
  98.   
  99.   
  100.     mysql_record_set* ret_set = NULL;  
  101.     ret_set = new mysql_record_set(retCount);  
  102.   
  103.     if(ret_set)  
  104.     {  
  105.         unsigned int j = 0;  
  106.         while((row = mysql_fetch_row(result)))//获取一行结果  
  107.         {  
  108.             unsigned long *lengths= mysql_fetch_lengths(result);//获取行长度  
  109.             mysql_record* rec = ret_set->get(j++);  
  110.             if(rec)  
  111.             {  
  112.                 for(unsigned int i=0; i<num_field; i++)  
  113.                 {  
  114.                     if(row[i] != NULL)  
  115.                     {  
  116.                         //g_log->debug("%s,%s,%lu", mysql_fields[i].name, row[i], lengths[i]);  
  117.                         rec->put(mysql_fields[i].name, row[i], lengths[i]);//放入结果（字段名、结果、长度）  
  118.                     }  
  119.                 }  
  120.             }  
  121.         }  
  122.     }  
  123.   
  124.     mysql_free_result(result);  
  125.   
  126.     if(ret_set && ret_set->size() == 0)  
  127.     {  
  128.         SAFE_DELETE(ret_set);  
  129.     }  
  130.   
  131.   
  132.     if(_select_time.elapse(realtime()) >= 3 * 1000L)//检查查询事件  
  133.     {  
  134.         g_log->warn("超时%llu毫秒sql:%s",_select_time.elapse(realtime()),query_string.str().c_str());  
  135.     }  
  136.     return ret_set;  
  137. }  


(2)执行sql

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. int mysql_handle::execSql(const char *sql,unsigned int sqllen,bool need_errlog)  
  2. {  
  3.     if (NULL == _mysql)  
  4.     {  
  5.         error_log("执行%s时_mysql指针为空,sql语句为%s",__FUNCTION__,sql);  
  6.         return -1;  
  7.     }  
  8.     if (NULL == sql)  
  9.     {  
  10.         error_log("执行%s时传入sql语句为空",__FUNCTION__);  
  11.         return -1;  
  12.     }  
  13.     if (0 == sqllen)  
  14.     {  
  15.         error_log("执行%s时sql语句%s长度为0",__FUNCTION__,sql);  
  16.         return -1;  
  17.     }  
  18.   
  19.     lastSql=sql;  
  20.     int ret=mysql_real_query(_mysql,sql,sqllen);  
  21.     if(ret && need_errlog)  
  22.     {     
  23.         error_log("%s", mysql_error(_mysql));  
  24.         error_log("%s", sql);  
  25.     }  
  26.     return ret;  
  27. }  


(3)查询使用实例

查询服务器列表

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mysql_record_set *recordset = NULL;  
  2. std::ostringstream oss;  
  3. mysql_record column,where;  
  4. mysql_handle *handle = mysqlPool->getHandle();//从句柄池获取句柄  
  5. if (!handle)  
  6. {  
  7.     g_log->error("不能从数据库连接池获取连接句柄");  
  8.     return false;  
  9. }  
  10. oss << "type=" << CENTERSERVER;  
  11. where.put("type",oss.str());//从服务器表格中查询类型为中心服务器的服务器配置  
  12. recordset = handle->exeSelect("SERVERLIST",NULL,&where);  
  13. if(recordset && recordset->size() == 1)//有结果且结果只有一条  
  14. {  
  15.     //只有一条满足条件的记录  
  16.     if (strcmp(pstrIP, recordset->get(0)->getvalue("ip")) == 0)//从结果集的第一条结果中获取字段为“ip”的值,且比较ip跟本服务器ip一致  
  17.     {  
  18.         wdServerID = recordset->get(0)->getvalue("id");//获取服务器id、名字、端口  
  19.                 this->name = (const char* )(recordset->get(0)->getvalue("name"));  
  20.         wdPort = recordset->get(0)->getvalue("port");  
  21.         wdExtPort = recordset->get(0)->getvalue("extport");  
  22.     }  
  23.     else  
  24.     {  
  25.         char temp[MAX_NAME_LEN];//结果不一致，输出日志  
  26.         strcpy(temp, recordset->get(0)->getvalue("name"));  
  27.         g_log->error("数据库中的记录不符合：%s, %s, %s", pstrIP, (const char *)recordset->get(0)->getvalue("ip"),(const char *)recordset->get(0)->getvalue("name"));  
  28.         SAFE_DELETE(recordset);  
  29.         mysqlPool->putHandle(handle);  
  30.         return false;  
  31.     }  
  32. }  
yiling2012
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
游戏服务器 数据库连接池 jdbc 简单封装
01-23
游戏服务器 数据库连接池 jdbc 简单封装
游戏服务器之主动连接线程池
陈嘉怡的专栏
02-12 1141
本文内容是游戏服务器之主动连接线程池,功能是实现处理服务器之间主动发起的连接的网络的数据收发。 一般来说，在场景服务器里连接其他服务器进程的连接是启动了新的线程的（如 场景服务器的主动连接：db服务器、社会服务器、日志服务器）。 但是也有不启动线程的客户端连接的做法。对于这类方式，他们的网络收发是统一由主动连接线程池来处理。 目前使用案例： 例如游戏服务器的网关服务器的主动连接：社会服务器
mysql句柄_MySQL与句柄_MySQL
weixin_36312811的博客
01-18 138
bitsCN.com1.环境OS:Win 2003 Server (X86)DB:MySQL 5.1.30-community-log2.问题MySQL Server占用的句柄数过大，使用过程消费句柄速度比释放速度来的快，部分其他应用申请不到句柄，导致不可用。2.1.Handle>handle.exe -s -p mysqld.exe01Handle type summary:02Deskt...
java游戏服务端mysql连接池_Java连接MySql用DBCP连接池的实现
weixin_32349699的博客
02-01 137
DBCP1.4或1.6依赖的jar包 DBCP参数说明 代码DBToolls.java文件测试test.java 运行结果 DBCP2以上版本依赖的jar包 DBCP2配置详细说明由于commons-dbcp所用的连接池出现版本升级，因此commons-dbcp2中的数据库池连接配置也发生了变化，具体的参数配置说明如下：常用连接配置 数据源连接数量配置提示: 如果在高负载的系统中将maxIdle...
易语言MYSQL连接池模块
08-16
易语言MYSQL连接池模块源码 系统结构:GetThis,初始化,关闭类线程,线程_测试,其他_附加文本,连接池初始化,取mysql句柄,释放mysql句柄,取空闲句柄数,销毁连接池,取_类_函数地址,取指针内容
MySQL 句柄数占用过多的解决方法
09-10
3. **使用连接池**：通过连接池管理数据库连接，避免频繁创建和关闭连接导致的句柄开销。 4. **定期清理无用的临时表**：长时间未使用的临时表会占用句柄，定期清理可释放资源。 5. **监控与调整其他InnoDB参数**：...
一个基于libmysql的MySQL数据库连接池.docx
11-20
1. 连接建立：首先通过`mysql_init()`初始化MYSQL句柄，然后使用`mysql_real_connect()`接口连接到数据库。如果数据库服务器和应用程序服务器不在同一主机，可能需要设置用户远程访问权限。 2. 连接释放：当不再需要...
java游戏服务端mysql连接池_java – 连接池中的Tomcat-Mysql连接在空闲时...
weixin_28934777的博客
01-21 54
我目前正在使用tomcat 6和MySQL 5.1.56.它使用Mysql Connector-j获取数据库连接并使用它们.我已根据此链接设置了连接池.只要我使用它,一切正常.如果我让它闲置几个小时,那么我就无法执行任何查询.我得到以下异常.com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: **No oper...
查看MySQL句柄,mysql常用命令
weixin_29609733的博客
03-27 400
mysql常用命令grant all on *.* to root@'192.168.10.131' identified by 'admin';LOAD DATA INFILE (从文件中导入数据)mysqldump -u pivot -p pivot news > c:\news.sql那么还原可以mysql命令，mysql -u 用户名 -p (密码) -h 主机名 --one-dat...
php mysql 数据句柄_php直接读取数据库信息
weixin_28703507的博客
02-02 118
连接到本机的3306，数据库的用户名是"root”，密码"123”，有一个数据库"redmine”，里面有一个表users，里面记录的是用户的相关信息，读取"id",”mail”,"created_on"的数据$db = mysql_connect(“localhost:3306”,"root”,"123");if(!$db){die(“error”);}mysql_select_db(“redm...
mysql连接池的原理_数据库连接池的基本原理
weixin_36061828的博客
02-19 254
欢迎进入Oracle社区论坛，与200万技术人员互动交流 >>进入 传统的数据库连接方式(指通过DriverManager和基本实现DataSource进行连接)中，一个数据库连接对象均对应一个物理数据库连接，数据库连接的建立以及关闭对系统而言是耗费系统资源的操作，在多层结欢迎进入Oracle社区论坛，与200万技术人员互动交流 >>进入传统的数据库连接方式(指通过Dri...
JVM堆内存中的句柄池详解
最新发布
学亮编程手记
11-29 448
同时，虚拟机会在句柄池中分配一个对应的句柄，并将句柄中的地址设置为对象实例数据的地址。许多现代的JVM实现已经转向直接指针访问模型，其中对象的实例数据直接存储在堆内存中，而不再需要句柄池进行间接访问。在使用句柄池的情况下，对象的实例数据可以在堆内存中任意移动，而不影响句柄的地址。句柄池位于堆内存的一部分，与存储对象实例数据的内存区域分开。每个对象在句柄池中都有一个对应的句柄，句柄中包含了对象实例数据的地址以及其他相关信息，如对象类型等。当使用句柄访问模型时，程序通过访问对象的句柄来间接访问对象的实例数据。
java 句柄池_java虚拟机内存区域的划分以及作用详解
weixin_39739234的博客
02-24 141
一、运行时数据区什么叫运行时数据区呢，看下图就知道了，今天的重点就围绕这张图讲。1、程序计数器(寄存器)当前线程所执行的字节码行号指示器字节码解释器工作依赖计数器控制完成通过执行线程行号记录，让线程轮流切换各条线程之间计数器互不影响线程私有，生命周期与线程相同，随JVM启动而生，JVM关闭而死线程执行Java方法时，记录其正在执行的虚拟机字节码指令地址线程执行Nativan方法时，计数器记录为空(...
java 句柄池_Java工程师的进阶之路 JVM篇（一）
weixin_29090677的博客
02-24 451
白菜Java自习室 涵盖核心知识1. JVM是什么JVM它是Java Virtual Machine 的缩写，主要是通过在实际计算机模仿各种计算机功能来实现的，组成部分包括堆、方法区、栈、本地方法栈、程序计算器等部分组成的，其中方法回收堆和方法区是共享区，也就是谁都可以使用，而栈和程序计算器、本地方法栈区是归JVM的。Java能够被称为“一次编译，到处运行”的原因就是Java屏蔽了很多的操作系统平...
mysql 文件句柄是什么_文件句柄概述
weixin_35907524的博客
01-19 444
Linux环境下句柄的理解在Linux下，我们使用ulimit -n 命令可以看到单个进程能够打开的最大文件句柄数量(socket连接也算在里面)。系统默认值1024。对于一般的应用来说(象Apache、系统进程)1024完全足够使用。但是如何象squid、mysql、java等单进程处理大量请求的应用来说就有点捉襟见肘了。如果单个进程打开的文件句柄数量超过了系统定义的值，就会提到“too man...
【MySql-Command】-DataBase
句柄在哪里
11-21 905
创建数据库 注意：创建数据库之前要先连接Mysql服务器 命令：create database 例1：建立一个名为xhkdb的数据库     mysql> create database mydb; 例2：创建数据库并分配用户 ①CREATE DATABASE 数据库名; ②GRANT SELECT,INSERT,UPDATE,DELETE,CREAT
句柄（handle）到底是什么？
Where？Here I'm.
05-19 2314
这篇文章的作者对网上各种handle的定义进行了汇总，比较之后讲解了为什么要有句柄？句柄的本质，以及句柄的结构。 http://blog.csdn.net/wenzhou1219/article/details/17659485点击打开链接
栈中对象定位的方式(句柄池，直接引用)
超负荷运转
05-13 1308
在我们A a = new A();的时候，一般有两种方式使栈中的a指向堆中的对象 句柄池 a变量知保存了指向句柄池的指针，由句柄池中的实例数据和类型数据指针，间接的访问实例和类型数据 直接指向 a变量直接指向堆中实例数据对象保存方法区类型数据指针，直接的访问实例数据 1.句柄池 当对象在垃圾回收时，地址会发生变动，而我们只需改变句柄池中的引用不用去栈中修改，但访问对象需要经过两步 直接引用 当对象在垃圾回收时，地址会发生变动，我们需要改变栈中的引用，但访问对象只需要经过一步 ...
MySQL数据库连接池设计与实现
"本文档主要介绍了如何创建一个基于libmysql的MySQL数据库连接池，适用于互联网相关的CS（计算机科学）领域。文档详细阐述了架构设计和数据库连接类的实现方法，旨在提高系统性能和数据安全性，降低耦合度，增强可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值