Ⅰ 数据库有几十万条数据，求高手指点如何处理并发
如果有20万条数据，5分钟内处理完成，那么每秒最少要处理600多条数据。你这个瓶颈在三个方面：
本地数据库读写，你这个需要数据库表不人导致死锁的，这个可以通过堆硬件性能（IO和CPU主频），数据库做好对应的索引提升查询速度，返回的结果先缓存到redis里，然后再写回去，应该是可以解决的
提交速度，每秒提交600条，这个靠单线程是肯定解决不了的，这需要多任务多线程处理。。。最好的方式是第三方网站可以批量查询
你以这么快的速度提交过去，第三方接口不一定能处理完成，可能有QPS限速的。这就不是你解决的了，需要第三方提升性能。
Ⅱ excel怎么样存10万数据
excel表中，一列数据有10万个数据，我要按顺序将每5000个数据分成一组
分很好分的，你打算把分后的数据放哪儿啊？
excel表格如何打开10万行的数据 如果有其他软件也请推荐一下
使用数据库程序打开，网上搜索哈，一大堆。
excel20多万行数据,如何分成一万一张的小表
这个如果要想批量处理，那么写代码是首选
不然得人工自己一万一万的分表复制粘贴另存。
EXCEL表格只能容纳6万条数据，有什么软件可以容纳10万条以上的数据呢？
可以用高版本的，不过这6万条是一个工作表，而一个EXCEL文档可以放很多张工作表的，可以把相关数据放在其它工作表中。
excel数据太长1万行怎么分成10份，一份1000……如图做示范，谢谢啦～
你要分10列还是10个工作表？
超过十万条的表格怎样用EXCEL打开
用EXCEL2007及其以上，打开，确切数字是：1048576行；16384列。
Excel是Microsoft Office system 中的电格程序。可以使用 Excel 创建工作簿（电子表格集合）并设置工作簿格式，以便分析数据和做出更明智的业务决策。特别是，可以使用 Excel 跟踪数据，生成数据分析模型，编写公式以对数据进行计算，以多种方式透视数据，并以各种具有专业外观的图表来显示数据。
求助，十几万条的excel表数据用什么配置能处理
CPU。inter 双核2.6Ghz以上，内存4G或以上，硬盘80G或以上都可以胜任你所说的文件，不是什么大困难。如果配置再低的话也可以，就是太卡啦。
excel表中，如何把B列10万条数据，按每999条分一组，进行分组查询。
如何快速填充公式1,填,可填充,如果前一列连续多行,则填充相同多行 方法2,先输入要填充式,按下SHIFT CTRL 方向键下,再按下CTRL D 方法3,按下SHIFT CTRL 方向键下,再在编辑栏里输入公式,再按下CTRL 回车 方法4,名称框输入需要填充的范围 (比如 A1:A54000) 回车 公式编辑栏输入要复制的公式后,同时按 CTRL 回车键输入 方法5,选中要填充的格子,按CTRL C(复制第一个带公式的单元格),然后鼠标移到名称框，直接输入列区间，如B3:B10000，回车，之后按CTRL V(点中该位置--右键粘贴)。 2和3的方法可填充至65536行 4和5方法就是要输入几行就是几行 你的要求合适用方法4
Ⅲ 缓存中有10万条数据，如何提高效率
这个例子给你看下！希望对你有帮助！是关于hash_table的！
struct hashFun
{
size_t operator()(int nVal) const
{
char szVal[64] = {0};
_itoa(nVal, szVal, 10);
const char* psz = szVal;
unsigned long _hash = 0;
for (; *psz != 0; ++psz)
{
_hash *= 16777619;
_hash ^= (unsigned long) (unsigned short&)*psz;
}
return _hash;
}
};
struct tableNode
{
int nValue;
DWORD nKey;
int nCount; //这个元素的个数
tableNode* pNext;
};
struct BoxVec
{
int nCount; //这个桶下的元素的类型的个数,可能不同的数在同一个桶下
int nMaxNum; //这个桶下这个元素出现的次数
int nVal;
tableNode* pHead;
};
class CMyHasTable
{
public:
CMyHasTable(const int* pBoxSize, int nBoxCount, int nLevel);
~CMyHasTable();
private:
int m_nBoxCount; //桶增长级数个数
const int* m_pBoxSize; //桶级数的值
int m_nBox; //桶的大小
int m_nLow; //桶个数的最小值
int m_nHight; //桶个数的最大值
int m_nLevel; //当前桶级数的索引
BoxVec* m_pBoxs;
int m_nSize; //元素的个数
public:
void Insert(int nVale);
int FindMaxCount();
private:
inline DWORD GetBoxIndex(DWORD key) const
{
return key & (m_nBox - 1);
}
inline DWORD GetBoxIndex(DWORD key, int nNewBox) const
{
return key & (nNewBox - 1);
}
private:
tableNode* Find(tableNode node);
void IncreaseLevel();
void SwitchLevel(int nNewLevel);
void UpBoxMaxCount(int nIndex);
};
.cpp文件
CMyHasTable::CMyHasTable(const int* pBoxSize, int nBoxCount, int nLevel)
{
m_pBoxSize = pBoxSize;
m_nBoxCount = nBoxCount;
m_nLevel = nLevel;
m_nHight = m_nBox = m_pBoxSize[m_nLevel];
m_nLow = m_nLevel > 0 ? m_pBoxSize[m_nLevel - 1]/2 : 0;
m_pBoxs = new BoxVec[m_nBox];
memset(m_pBoxs, 0, sizeof(BoxVec) * m_nBox);
m_nSize = 0;
}
CMyHasTable::~CMyHasTable()
{
for (int i = 0; i < m_nBox; ++i)
{
tableNode* p = m_pBoxs[i].pHead;
while (p != NULL)
{
tableNode* q = p->pNext;
delete p;
p = q;
}
}
delete[] m_pBoxs;
}
void CMyHasTable::Insert(int nVale)
{
tableNode valNode;
valNode.nValue = nVale;
valNode.nKey = hashFun()(nVale);
valNode.pNext = NULL;
tableNode* pNode = Find(valNode);
if (pNode == NULL)
{
m_nSize ++;
tableNode* pNew = new tableNode;
*pNew = valNode;
pNew->nCount = 1;
DWORD dwBoxIndex = GetBoxIndex(valNode.nKey);
pNew->pNext = m_pBoxs[dwBoxIndex].pHead;
m_pBoxs[dwBoxIndex].pHead = pNew;
m_pBoxs[dwBoxIndex].nCount++;
m_pBoxs[dwBoxIndex].nMaxNum = 1;
m_pBoxs[dwBoxIndex].nVal = nVale;
if (m_nSize >= m_nHight)
IncreaseLevel();
}
else
{
pNode->nCount++;
DWORD dwBoxIndex = GetBoxIndex(pNode->nKey);
UpBoxMaxCount(dwBoxIndex);
}
}
int CMyHasTable::FindMaxCount()
{
int nMaxCount = m_pBoxs[0].nMaxNum;
int nIndex = 0;
for (int i = 1; i < m_nBox; i++)
{
if (nMaxCount < m_pBoxs[i].nMaxNum)
{
nMaxCount = m_pBoxs[i].nMaxNum;
nIndex = i;
}
}
return m_pBoxs[nIndex].nVal;
}
void CMyHasTable::UpBoxMaxCount(int nIndex)
{
tableNode* p = m_pBoxs[nIndex].pHead;
tableNode* q = p;
int nMax = p->nCount;
while(p->pNext)
{
if (nMax < p->nCount)
{
nMax = p->nCount;
q = p;
}
p = p->pNext;
}
m_pBoxs[nIndex].nMaxNum = nMax;
m_pBoxs[nIndex].nVal = q->nValue;
}
tableNode* CMyHasTable::Find(tableNode node)
{
DWORD short_key = GetBoxIndex(node.nKey);
tableNode* p = m_pBoxs[short_key].pHead;
while (p != NULL)
{
if (p->nKey == node.nKey)
{
if (p->nValue == node.nValue)
return p;
}
p = p->pNext;
}
return NULL;
}
void CMyHasTable::IncreaseLevel()
{
if (m_nLevel < m_nBoxCount - 1)
SwitchLevel(m_nLevel + 1);
else
m_nHight = 0x20000000;
}
void CMyHasTable::SwitchLevel(int nNewLevel)
{
m_nLevel = nNewLevel;
int nNewBox = m_pBoxSize[m_nLevel];
BoxVec* pNewBoxs = new BoxVec[nNewBox];
memset(pNewBoxs, 0, sizeof(BoxVec) * nNewBox);
for (int i = 0; i < m_nBox; ++i)
{
tableNode* p = m_pBoxs[i].pHead;
tableNode* q = NULL;;
int nCout = m_pBoxs[i].nCount;
int nMax = m_pBoxs[i].nMaxNum;
while (p != NULL)
{
q = p->pNext;
DWORD sht_key = GetBoxIndex(p->nKey, nNewBox);
p->pNext = pNewBoxs[sht_key].pHead;
pNewBoxs[sht_key].pHead = p;
p = q;
pNewBoxs[sht_key].nCount = nCout;
pNewBoxs[sht_key].nMaxNum = nMax;
}
}
m_nHight = m_nBox = m_pBoxSize[m_nLevel];
m_nLow = m_nLevel > 0 ? m_pBoxSize[m_nLevel - 1]/2 : 0;
delete m_pBoxs;
m_pBoxs = pNewBoxs;
}
Ⅳ 2：在数据库中如何处理几十万条并发数据
只要不指定主键,并发的增,是没有问题的. 并发访问的话,数据库是有默认的并发访问处理级别的. 另外可以使用悲观锁,乐观锁来实现数据并发访问的问题. 几十万条的数据并发访问会在国家级,门户级别的服务器上出现.其他的并发数据.则不多见,除非出现数据攻击. 不过考虑现在的服务器硬件级别和数据处理能力,这种情况,很少会使用这种数据攻击.
麻烦采纳，谢谢!