无锁缓存，每秒10万并发，究竟如何实现？

有一类业务场景：

（1）超高吞吐量，每秒要处理海量请求；

（2）写多读少，大部分请求是对数据进行修改，少部分请求对数据进行读取；

这类业务，有什么实现技巧么？

接下来，一起听我从案例入手，娓娓道来。

void SetDriverInfo(long driver_id, DriverInfo info){

         WriteLock (m_lock);

         Map<driver_id>= info;

         UnWriteLock(m_lock);

}

DriverInfo GetDriverInfo(long driver_id){

         DriverInfo t;

         ReadLock(m_lock);

         t= Map<driver_id>;

         UnReadLock(m_lock);

         return t;

}

有什么潜在的优化方法么？

锁冲突之所以严重，是因为整个Map共用一把锁，锁的粒度太粗。

画外音：可以认为是一个数据库的“库级别锁”。

是否可能进行水平拆分，来降低锁冲突呢？

答案是肯定的。

画外音：类似于数据库里的分库，把一个库锁变成多个库锁，来提高并发，降低锁冲突。

我们可以把1个Map水平切分成N个Map：

void SetDriverInfo(long driver_id, DriverInfo info){

         i = driver_id % N; // 水平拆分成N份，N个Map，N个锁

         WriteLock (m_lock[i]);  //锁第i把锁

         Map[i]<driver_id>= info;  // 操作第i个Map

         UnWriteLock (m_lock[i]); // 解锁第i把锁

}

有没有可能，进一步细化锁粒度，一个元素一把锁呢？

答案也是肯定的。

画外音：可以认为是一个数据库的“库级别锁”，优化为“行级别锁”。

void SetDriverInfo(long driver_id, DriverInfo info){

         index = driver_id;

         WriteLock (m_lock[index]);  //超级大内存，一条记录一个锁，锁行锁

         Array[index]= info; //driver_id就是Array下标

         UnWriteLock (m_lock[index]); // 解锁行锁

}

这个方案使得锁冲突降到了最低，但锁资源大增，在数据量非常大的情况下，内存往往是装不下的。

写多读少的业务，有一种优化方案：无锁缓存，将锁冲突降低到。

（1）线程1对缓存进行操作，对key想要写入value1；

总结