轮胎235/55r19101v什么意思（(2356)SQLite多线程下的并发操作_飞翔的种子_百度空间）

SQLite多线程下的并发操作

这两天一直在捣鼓SQLite数据库    
    
    
，基本的操作就不说了    


     


     


  ，比较简单




 




 




 
，打算有空的话另起一篇博文简单总结一下   
    
    
  。

这里主要想探讨一下多路并发下的数据库操作

SQLite作为一款小型的嵌入式数据库   

   

   

，本身没有提供复杂的锁定机制     

     

     

 ，无法内部管理多路并发下的数据操作同步问题




  




  




  ，更谈不上优化
  


  


  


，所以涉及到多路并发的情况     
     
     
，需要外部进行读写锁控制 




   




   




   ，否则SQLite会返回SQLITE_BUSY错误

 



 



 


，以驳回相关请求


     


     


     
。

如果有朋友想了解SQLite相关的锁定机制               ，可以看看我转载的博文sqlite的事务和锁  




    




    




   ，讲解的比较透彻















，也容易理解               ，这里就不再重复讲解了 




 




 




。

返回SQLITE_BUSY主要有以下几种情况：

1   

   

   

 。当有写操作时   



     



     



   ，其他读操作会被驳回

2

     

     

     。当有写操作时















，其他写操作会被驳回

3
  




  




  




。当开启事务时    
    
    
，在提交事务之前    


     


     


  ，其他写操作会被驳回

4  


  


  


。当开启事务时




 




 




 
，在提交事务之前   

   

   

，其他事务请求会被驳回

5 
     
     
     。当有读操作时     

     

     

 ，其他写操作会被驳回

6

   




   




   



。读操作之间能够并发执行

基于以上讨论




  




  




  ，可以看出这是一个典型的读者写者问题
  


  


  


，读操作要能够共享     
     
     
，写操作要互斥 




   




   




   ，读写之间也要互斥

可以设计如下的方案解决并发操作数据库被锁定的问题

 



 



 


，同时保证读操作能够保持最大并发

1 



 



 



。采用互斥锁控制数据库写操作

2                。只有拥有互斥锁的线程才能够操作数据库

3


    




    




    


。写操作必须独立拥有互斥锁

4














。读操作必须能够共享互斥锁               ，即在第一次读取的时候获取互斥锁  




    




    




   ，最后一次读取的时候释放互斥锁

具体的代码实现就不贴了















，有了思路               ，实现就很简单了   



     



     



   ，欢迎大家一起讨论！

下面是我简单编写的一个共享锁















，smutex是一个跨平台的锁实现    
    
    
，简单    


     


     


  ，不多说了：

// 共享锁




 




 




 
，第一个进入时锁定   

   

   

，最后一个离开时释放

class shared_mutex

{

private:

static int taked_man_; // 当前持有该锁的线程数

static sp::smutex man_lock_; // taked_man_的修改锁

private:

// 自动模式

bool is_auto_;

sp::smutex *mutex;

public:

void aquire()

{

sp::sguard<sp::smutex> auto_lock(shared_mutex::man_lock_);

if(taked_man_ == 0)

{

mutex->acquire();

}

taked_man_++;

}

void release()

{

sp::sguard<sp::smutex> auto_lock(shared_mutex::man_lock_);

if(this->taked_man_ > 0)

{

taked_man_--;

if(taked_man_ == 0)

{

mutex->release();

}

}

}

public:

shared_mutex(sp::smutex &mt, bool auto_ = true) : mutex(&mt)

{

sp::sguard<sp::smutex> auto_lock(shared_mutex::man_lock_);

this->is_auto_ = auto_;

if(this->is_auto_)

{

this->aquire();

}

}

~shared_mutex()

{

sp::sguard<sp::smutex> auto_lock(shared_mutex::man_lock_);

if(this->is_auto_)

{

this->release();

}

}

};