nginx源码学习4——重写共享内存锁类

先贴代码，细节以后有必要再加。

mytool_lock_base.h：

#ifndef MYTOOL_LOCK_BASE_H
#define MYTOOL_LOCKS_BASE_H

#include <sched.h>
#include <unistd.h>
#include <sys/types.h>
namespace mytool{
/* GCC 4.1 builtin atomic operations */
typedef volatile long atomic_int_t;
typedef volatile unsigned long atomic_uint_t;
//nginx只有增和赋值0、1的需求，所以nginx的atomic_t是unsigned的
typedef atomic_int_t atomic_t;

//__sync_bool_compare_and_swap,gcc built in函数，如果plock指向值等于old，则设置*plock为set，返回1；否则返回0；
//本机x86_64构架，g++ -S显示关键汇编指令为lock cmpxchg
inline bool atomic_cmp_set(atomic_t *plock,atomic_t old,atomic_t set){
return __sync_bool_compare_and_swap(plock,old,set);
}
//__sync_fetch_and_add,buitin函数，value+add并赋值回value，返回value旧值
//关键汇编指令为lock addq
//nginx仅仅只需要增加值
inline atomic_t atomic_fetch_add(atomic_t *pvalue,atomic_t add){
return __sync_fetch_and_add(pvalue,add);
}
//nginx更新时间字符串时会用到
//能否inline？
#define mytool_memory_barrier() __sync_synchronize()

//当前单线程的nginx主流程实际只用到的两个加锁函数，加锁失败，立即返回，不强求
//单线程只需给信号处理函数和正常流程冲突部分加锁，如果用下面的自旋锁（同时也实现了互斥锁）函数加锁，会引起死锁
inline bool trylock(atomic_t *plock){
return *(plock) == 0 && atomic_cmp_set(plock,0,1);
}
inline void unlock(atomic_t *plock){
*(plock) = 0;
}

//扒自ngx_spinlock，实际功效和名字不同，根据参数和环境的不同，可以体现为自旋锁、互斥锁或二者结合形式
//nginx本函数没有实际使用场景，但是类似代码在ngx_shmtx.c内有
#define mytool_cpu_pause() __asm__ ("pause")
inline void spinlock(atomic_t *lock,atomic_t value,unsigned spin){
static unsigned ncpu = 0;
unsigned i,n;
for (;;){
if(*lock == 0 && atomic_cmp_set(lock,0,value))
return;
if(ncpu == 0)
ncpu = sysconf(_SC_NPROCESSORS_ONLN);
if(ncpu > 1){
for(n = 1;n < spin;n <<= 1){
for(i = 0;i < n;i++)
mytool_cpu_pause();
if(*lock == 0 && atomic_cmp_set(lock,0,value))
return;
}
}
sched_yield();
}
}

}

#endif

mytool_shmlock.h
#ifndef MYTOOL_SHMLOCK_H
#define MYTOOL_SHMLOCK_H
#include "mytool_lock_base.h"

//nginx代码内实现了多种形式的互斥，原子操作trylock、自旋锁、信号量、互斥锁，但是当前nginx的单线程多路复用模式使得工作进程挂起于某种事件不能接收。所以实际上使用的也就是trylock，得不到就放手。
//进程间的互斥用原子操作trylock+共享内存实现，也是接下来要试图扒取的
//认为会作为全局变量使用，没有收回内存
namespace mytool{
class Shmlock{
public:
//拷贝、赋值等禁止操作delete，todo
//可以增加当前锁持有时间+试图解锁计数，每次tryLock计数自减，为0时说明长时间没有释放或者获得锁需求很大，此时应该打印日志，todo
inline bool tryLock() noexcept(true){
return mytool::trylock(&lock);
}
//可以加当前lock的持有者pid，unlock时验证，todo
inline void unlock() noexcept(true){
mytool::unlock(&lock);
}
static Shmlock *getNewShmlock() noexcept(false);
private:
static key_t _smid;
static Shmlock *_shm;
static unsigned _idcount;
const static unsigned _maxnid = 20;
Shmlock():lock(0) {}
atomic_t lock;
};
}

#endif

mytool_shmlock.cpp
#include "mytool_shmlock.h"
#include <sys/shm.h>
#include <stdexcept>
#include <stdio.h>
#include <string.h>

namespace mytool{

key_t Shmlock::_smid = -1;
Shmlock *Shmlock::_shm = NULL;
unsigned Shmlock::_idcount = 0;
Shmlock *Shmlock::getNewShmlock() noexcept(false) {
//初始化
if(_smid < 0){
if((_smid = shmget(0,sizeof(Shmlock) * _maxnid,0666|IPC_CREAT)) < 0)
throw std::runtime_error(strerror(errno));
if(((long)(_shm = (Shmlock *)shmat(_smid,NULL,0))) == -1)
throw std::runtime_error(strerror(errno));
}
if(_idcount >= _maxnid)
throw std::overflow_error("too many shmlock built");
//Shmlock::Shmlock(_shm + _idcount);
new (_shm + _idcount) Shmlock;
return _shm + _idcount++;
}

}

最后的测试cpp：
#include "mytool_shmlock.h"
#include <stdio.h>
#include <unistd.h>

using namespace mytool;
int main(){
Shmlock *psm0 = Shmlock::getNewShmlock();
//此时psm测试第二个lock
Shmlock *psm = Shmlock::getNewShmlock();
if(fork() == 0){
if(psm->tryLock()){
printf("son got lock\n");
sleep(1);
psm->unlock();
printf("son releaed lock\n");
}
else{
printf("son failed to get lock\n");
}
return 0;
}
sleep(1);
if(psm->tryLock())
printf("parent got lock\n");
else{
printf("parent failed to get lock\n");
sleep(3);
if(psm->tryLock())
printf("parent finally got the lock\n");
psm->unlock();
}
return 0;
}

输出：
son got lock

parent failed to get lock

son releaed lock

parent finally got the lock

符合预期。