64,643
社区成员
发帖
与我相关
我的任务
分享多线程怎么重复利用？？
要写200个数据我分成两个线程去写 不过领导说要按照另一种思路写：还是两个线程，一个线程只处理10个数据 谁先处理完 谁继续再去处理接下的10个数据 ，直到所有数据处理完，我不知道怎么写 求指点
这是我现在写的思路
#include <Windows.h>
#include <iostream>
using namespace std;
DWORD WINAPI Thread1(LPVOID lpParmeter);
DWORD WINAPI Thread2(LPVOID lpParmeter);
int main()
{
HANDLE hThread1 ;
HANDLE hThread2 ;
hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);
hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);
HANDLE h[2]={hThread1,hThread2};
WaitForMultipleObjects(2,h,true, INFINITE);//等待所有线程完成后，退出
CloseHandle(hThread1);
CloseHandle(hThread2);
system("PAUSE");
return 0;
}
DWORD WINAPI Thread1(LPVOID lpParmeter)
{
//1到100的处理过程
for each 1 to 100
deal(...);
return 0;
}
DWORD WINAPI Thread2(LPVOID lpParameter)//thread data
{
//100到200的处理过程
for each 100 to 200
deal(...);
return 0;
}
这是我现在写的思路
...全文
请发表友善的回复…
发表回复
有新工作否 2013-06-08
- 打赏
- 举报
还是必须要用临界区，不然会丢失一些数据，新代码如下
#include <Windows.h>
#include <iostream>
#include <fstream>
using namespace std;
struct Numbers
{
int number;
bool IsDoing;
bool HaveDone;
};
Numbers NumbersArray[20000];
DWORD WINAPI Thread1(Numbers* pNumbers1);
DWORD WINAPI Thread2(Numbers* pNumbers2);
CRITICAL_SECTION g_CriticalSection;
int main()
{
//为numbers赋值
for(int i = 1;i<=20000;i++)
{
NumbersArray[i].number = i;
NumbersArray[i].IsDoing = false;
NumbersArray[i].HaveDone = false;
}
HANDLE hThread1 ;
HANDLE hThread2 ;
Numbers* pNumbers1 = NumbersArray;
Numbers* pNumbers2 = NumbersArray;
InitializeCriticalSection(&g_CriticalSection); // 初始化
hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Thread1, pNumbers1, 0, NULL);
hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Thread2, pNumbers2, 0, NULL);
HANDLE h[2]={hThread1,hThread2};
WaitForMultipleObjects(2,h,true, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
DeleteCriticalSection(&g_CriticalSection); // 删除
system("PAUSE");
return 0;
}
DWORD WINAPI Thread1(Numbers* pNumbers1)
{
while(pNumbers1->number < 20000)
{
EnterCriticalSection(&g_CriticalSection); //进入临界区
ofstream file1("123.txt",ofstream::app);
if(pNumbers1->IsDoing == false && pNumbers1->HaveDone == false)
{
pNumbers1->IsDoing = true;
for(int i =0;i<10;i++)
{
file1<<"Thread1 deal with"<<(pNumbers1+i)->number<<endl;
//Sleep(10);
}
pNumbers1->HaveDone = true;
}
else
pNumbers1+=10;
file1.close();
LeaveCriticalSection(&g_CriticalSection);
}
return 0;
}
DWORD WINAPI Thread2(Numbers* pNumbers2)
{
while(pNumbers2->number < 20000)
{
EnterCriticalSection(&g_CriticalSection); //进入临界区
ofstream file2("123.txt",ofstream::app);
if(pNumbers2->IsDoing == false && pNumbers2->HaveDone == false)
{
pNumbers2->IsDoing = true;
for(int i =0;i<10;i++)
{
file2<<"Thread2 deal with"<<(pNumbers2+i)->number<<endl;
//Sleep(10);
}
pNumbers2->HaveDone = true;
}
else
pNumbers2+=10;
file2.close();
LeaveCriticalSection(&g_CriticalSection);
}
return 0;
}
有新工作否 2013-06-08
- 打赏
- 举报
运行的时间比较长，为了压力测试一下，会不会造成数据冲突。如果楼主不想测试，直接把Sleep(10)去掉。大概需要200多秒才运行好。
有新工作否 2013-06-08
- 打赏
- 举报
楼主的毅力我很佩服，一个帖子不成还开一个帖子。。
那天我就说了楼主了，你这样的效率很低的，还不如开始就分配好内存，让2个线程直接去取数据，不要这样动态。
不过楼主的毅力很不错，我写了个2线程取数据的，楼主测试看看吧。
#include <Windows.h>
#include <iostream>
#include <fstream>
using namespace std;
struct Numbers
{
int number;
bool IsDoing;
bool HaveDone;
};
Numbers NumbersArray[20000];
DWORD WINAPI Thread1(Numbers* pNumbers1);
DWORD WINAPI Thread2(Numbers* pNumbers2);
int main()
{
HANDLE hThread1 ;
HANDLE hThread2 ;
//为numbers赋值
for(int i = 1;i<=20000;i++)
{
NumbersArray[i].number = i;
NumbersArray[i].IsDoing = false;
NumbersArray[i].HaveDone = false;
}
Numbers* pNumbers1 = NumbersArray;
Numbers* pNumbers2 = NumbersArray;
hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Thread1, pNumbers1, 0, NULL);
hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Thread2, pNumbers2, 0, NULL);
HANDLE h[2]={hThread1,hThread2};
WaitForMultipleObjects(2,h,true, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
system("PAUSE");
return 0;
}
DWORD WINAPI Thread1(Numbers* pNumbers1)
{
while(pNumbers1->number < 20000)
{
ofstream file1("123.txt",ofstream::app);
if(pNumbers1->IsDoing == false && pNumbers1->HaveDone == false)
{
pNumbers1->IsDoing = true;
for(int i =0;i<10;i++)
{
file1<<"Thread1 deal with"<<(pNumbers1+i)->number<<endl;
Sleep(10);
}
pNumbers1->HaveDone = true;
}
else
pNumbers1+=10;
file1.close();
}
return 0;
}
DWORD WINAPI Thread2(Numbers* pNumbers2)
{
while(pNumbers2->number < 20000)
{
ofstream file2("123.txt",ofstream::app);
if(pNumbers2->IsDoing == false && pNumbers2->HaveDone == false)
{
pNumbers2->IsDoing = true;
for(int i =0;i<10;i++)
{
file2<<"Thread2 deal with"<<(pNumbers2+i)->number<<endl;
Sleep(10);
}
pNumbers2->HaveDone = true;
}
else
pNumbers2+=10;
file2.close();
}
return 0;
}
lm_whales 2013-06-08
- 打赏
- 举报
#include<stdlib.h>
#include <time.h>
#include <Windows.h>
#include <iostream>
using namespace std;
//DWORD WINAPI Thread1(LPVOID lpParmeter);
//DWORD WINAPI Thread2(LPVOID lpParmeter);
//假设数据类型为 int；
typedef int datatype;
struct taskParam{
int buf[1000];
int sleep[100];
int curpos;
CRITICAL_SECTION cs;
};
struct ThreadParam{
int no;
int len;
int start;
taskParam *ptask;
};
void InitTask(taskParam &task){
task.curpos=0;
for(int i=0;i<100;i++)
task.buf[i]=i;
srand(time(NULL));//方便下面的模拟操作
InitializeCriticalSection(&task.cs);
}
void FinshedTask(taskParam &task){
task.curpos=0;
DeleteCriticalSection(&task.cs);
}
void PrintMsg(ThreadParam *pParam,char *msg){
EnterCriticalSection(&pParam->ptask->cs);
cout<<msg<<": Thread "<<pParam->no <<endl;
cout<<" pos =" << pParam->start<<",length= "<<pParam->len<<endl;
LeaveCriticalSection(&pParam->ptask->cs);
}
int getTask(ThreadParam *pParam){
int pos=1000;
int ret=0;
EnterCriticalSection(&pParam->ptask->cs);
pos =pParam->ptask->curpos;
if(pos<1000){
pParam->start =pos;
pParam->len=10;
pParam->ptask->curpos+=10;
ret =10;
}
else ret =0;
LeaveCriticalSection(&pParam->ptask->cs);
// PrintMsg(pParam,"gettask task");
return ret;
}
void DealTask(ThreadParam *pParam){
// 处理任务
//int n=1.0*rand()/RAND_MAX *500+10;
char msg[1024]="deal task";
//sprintf(msg,"deal task sleep %d",n);
PrintMsg(pParam, msg);
// 这用来，模拟处理任务。
for (int i=pParam->start; i< pParam->start+ pParam->len;i++)
pParam->ptask->buf[i]*=2; //假设实际这样处理
//Sleep(n);
}
DWORD WINAPI ThreadProc(LPVOID lpParmeter);
int main() {
HANDLE hThread1 ;
HANDLE hThread2 ;
taskParam task;
InitTask(task);
ThreadParam param[2]={{0,0,0,&task},{1,0,0,&task}};
hThread1 = CreateThread(NULL, 0, ThreadProc, param, 0, NULL);
hThread2 = CreateThread(NULL, 0, ThreadProc, param+1, 0, NULL);
HANDLE h[2]={hThread1,hThread2};
WaitForMultipleObjects(2,h,true, INFINITE);//等待所有线程完成后，退出
CloseHandle(hThread1);
CloseHandle(hThread2);
FinshedTask(task);
system("PAUSE");
return 0;
}
DWORD WINAPI ThreadProc(LPVOID lpParmeter){
ThreadParam *pParam=(ThreadParam *)lpParmeter;
while(getTask(pParam)){
DealTask(pParam);
}
return 0;
}
// DWORD WINAPI Thread2(LPVOID lpParameter)//thread data
//{ //100到200的处理过程
//for each 100 to 200
//deal(...); return 0;
//}
lm_whales 2013-06-08
- 打赏
- 举报
在线程里
开一循环，如果有数据要处理读取10个数据没有线程退出
对取数据，进行同步就可以了
#include<stdlib.h>
#include <time.h>
#include <Windows.h>
#include <iostream>
using namespace std;
//DWORD WINAPI Thread1(LPVOID lpParmeter);
//DWORD WINAPI Thread2(LPVOID lpParmeter);
//假设数据类型为 int；
typedef int datatype;
struct taskParam{
int buf[1000];
int sleep[100];
int curpos;
CRITICAL_SECTION cs;
};
struct ThreadParam{
int no;
int len;
int start;
taskParam *ptask;
};
void InitTask(taskParam &task){
task.curpos=0;
for(int i=0;i<100;i++)
task.buf[i]=i;
srand(time(NULL));//方便下面的模拟操作
InitializeCriticalSection(&task.cs);
}
void FinshedTask(taskParam &task){
task.curpos=0;
DeleteCriticalSection(&task.cs);
}
void PrintMsg(ThreadParam *pParam,char *msg){
EnterCriticalSection(&pParam->ptask->cs);
cout<<msg<<": Thread "<<pParam->no <<endl;
cout<<" pos =" << pParam->start<<",length= "<<pParam->len<<endl;
LeaveCriticalSection(&pParam->ptask->cs);
}
int getTask(ThreadParam *pParam){
int pos=1000;
int ret=0;
EnterCriticalSection(&pParam->ptask->cs);
pos =pParam->ptask->curpos;
if(pos<1000){
pParam->start =pos;
pParam->len=10;
pParam->ptask->curpos+=10;
ret =10;
}
else ret =0;
LeaveCriticalSection(&pParam->ptask->cs);
// PrintMsg(pParam,"gettask task");
return ret;
}
void DealTask(ThreadParam *pParam){
// 处理任务
//int n=1.0*rand()/RAND_MAX *500+10;
char msg[1024]="deal task";
//sprintf(msg,"deal task sleep %d",n);
PrintMsg(pParam, msg);
// 这用来，模拟处理任务。
for (int i=pParam->start; i< pParam->start+ pParam->len;i++)
pParam->ptask->buf[i]*=2; //假设实际这样处理
//Sleep(n);
}
DWORD WINAPI ThreadProc(LPVOID lpParmeter);
int main() {
HANDLE hThread1 ;
HANDLE hThread2 ;
taskParam task;
InitTask(task);
ThreadParam param[2]={{0,0,0,&task},{1,0,0,&task}};
hThread1 = CreateThread(NULL, 0, ThreadProc, param, 0, NULL);
hThread2 = CreateThread(NULL, 0, ThreadProc, param+1, 0, NULL);
HANDLE h[2]={hThread1,hThread2};
WaitForMultipleObjects(2,h,true, INFINITE);//等待所有线程完成后，退出
CloseHandle(hThread1);
CloseHandle(hThread2);
FinshedTask(task);
system("PAUSE");
return 0;
}
DWORD WINAPI ThreadProc(LPVOID lpParmeter){
ThreadParam *pParam=(ThreadParam *)lpParmeter;
while(getTask(pParam)){
DealTask(pParam);
}
return 0;
}
// DWORD WINAPI Thread2(LPVOID lpParameter)//thread data
//{ //100到200的处理过程
//for each 100 to 200
//deal(...); return 0;
//}
qq120848369 2013-06-06
- 打赏
- 举报
条件变量+互斥锁+队列
赵4老师 2013-06-06
- 打赏
- 举报
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <process.h>
#include <io.h>
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
void Lock(CRITICAL_SECTION *l) {
EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
LeaveCriticalSection(l);
}
void LogV(const char *pszFmt,va_list argp) {
struct tm *now;
struct timeb tb;
if (NULL==pszFmt||0==pszFmt[0]) return;
_vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
ftime(&tb);
now=localtime(&tb.time);
sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
sprintf(timestr,"%02d:%02d:%02d",now->tm_hour ,now->tm_min ,now->tm_sec );
sprintf(mss,"%03d",tb.millitm);
printf("%s %s.%s %s",datestr,timestr,mss,logstr);
flog=fopen(logfilename1,"a");
if (NULL!=flog) {
fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
if (ftell(flog)>MAXLOGSIZE) {
fclose(flog);
if (rename(logfilename1,logfilename2)) {
remove(logfilename2);
rename(logfilename1,logfilename2);
}
} else {
fclose(flog);
}
}
}
void Log(const char *pszFmt,...) {
va_list argp;
Lock(&cs_log);
va_start(argp,pszFmt);
LogV(pszFmt,argp);
va_end(argp);
Unlock(&cs_log);
}
//Log}
#define ASIZE 200
#define BSIZE 240
#define CSIZE 2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX ;
CRITICAL_SECTION cs_BBB ;
struct FIFO_BUFFER {
int head;
int tail;
int size;
char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
int i,j,k;
char binstr[80];
Lock(&cs_HEX);
for (i=0;i<len;i++) {
if (0==(i%16)) {
sprintf(binstr,"%03d %04x -",cn,i);
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
} else if (15==(i%16)) {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
sprintf(binstr,"%s ",binstr);
for (j=i-15;j<=i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
} else {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
}
}
if (0!=(i%16)) {
k=16-(i%16);
for (j=0;j<k;j++) {
sprintf(binstr,"%s ",binstr);
}
sprintf(binstr,"%s ",binstr);
k=16-k;
for (j=i-k;j<i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
}
Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
lent=0;
Lock(cs);
if (fbuf->size>=len) {
lent=len;
if (fbuf->head+lent>BSIZE) {
len1=BSIZE-fbuf->head;
memcpy(buf ,fbuf->data+fbuf->head,len1);
len2=lent-len1;
memcpy(buf+len1,fbuf->data ,len2);
fbuf->head=len2;
} else {
memcpy(buf ,fbuf->data+fbuf->head,lent);
fbuf->head+=lent;
}
fbuf->size-=lent;
}
Unlock(cs);
return lent;
}
void thdB(void *pcn) {
char *recv_buf;
int recv_nbytes;
int cn;
int wc;
int pb;
cn=(int)pcn;
Log("%03d thdB thread begin...\n",cn);
while (1) {
Sleep(10);
recv_buf=(char *)Cbuf;
recv_nbytes=CSIZE;
wc=0;
while (1) {
pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
if (pb) {
Log("%03d recv %d bytes\n",cn,pb);
HexDump(cn,recv_buf,pb);
Sleep(1);
} else {
Sleep(1000);
}
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
Lock(cs);
lent=len;
if (fbuf->size+lent>BSIZE) {
lent=BSIZE-fbuf->size;
}
if (fbuf->tail+lent>BSIZE) {
len1=BSIZE-fbuf->tail;
memcpy(fbuf->data+fbuf->tail,buf ,len1);
len2=lent-len1;
memcpy(fbuf->data ,buf+len1,len2);
fbuf->tail=len2;
} else {
memcpy(fbuf->data+fbuf->tail,buf ,lent);
fbuf->tail+=lent;
}
fbuf->size+=lent;
Unlock(cs);
return lent;
}
void thdA(void *pcn) {
char *send_buf;
int send_nbytes;
int cn;
int wc;
int a;
int pa;
cn=(int)pcn;
Log("%03d thdA thread begin...\n",cn);
a=0;
while (1) {
Sleep(100);
memset(Abuf,a,ASIZE);
a=(a+1)%256;
if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
send_buf=(char *)Abuf;
send_nbytes=ASIZE;
Log("%03d sending %d bytes\n",cn,send_nbytes);
HexDump(cn,send_buf,send_nbytes);
wc=0;
while (1) {
pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
Log("%03d sent %d bytes\n",cn,pa);
HexDump(cn,send_buf,pa);
send_buf+=pa;
send_nbytes-=pa;
if (send_nbytes<=0) break;//
Sleep(1000);
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
}
int main() {
InitializeCriticalSection(&cs_log );
Log("Start===========================================================\n");
InitializeCriticalSection(&cs_HEX );
InitializeCriticalSection(&cs_BBB );
BBB.head=0;
BBB.tail=0;
BBB.size=0;
_beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
_beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
if (!access("No_Loop",0)) {
remove("No_Loop");
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
while (1) {
Sleep(1000);
if (No_Loop) break;//
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
Sleep(3000);
DeleteCriticalSection(&cs_BBB );
DeleteCriticalSection(&cs_HEX );
Log("End=============================================================\n");
DeleteCriticalSection(&cs_log );
return 0;
}
大尾巴猫 2013-06-06
- 打赏
- 举报
#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;
const int Threadnum = 2; //线程数量
const int Questnum = 200; //任务数量
struct Threadarg //传入线程函数的参数结构
{
volatile int* p_count;
int* p_data;
CRITICAL_SECTION* p_cs;
};
unsigned int _stdcall proc(void* argv); //线程入口函数
int main()
{
int data[Questnum]; //模拟任务的数组
for (int i = 0; i < Questnum; i++)
{
data[i] = i;
}
volatile int count = 0; //控制变量
CRITICAL_SECTION cs;
InitializeCriticalSectionAndSpinCount(&cs,4000); //关键段初始化
//设定参数
Threadarg arg;
arg.p_count = &count;
arg.p_data = data;
arg.p_cs = &cs;
HANDLE h[Threadnum];
for (int i = 0; i < Threadnum; i++)
{
h[i] = (HANDLE) _beginthreadex(NULL, 0, proc, (void*)&arg, 0, NULL); //最好用_beginthreadex函数创建线程，不要用createthread
}
WaitForMultipleObjects(Threadnum, h, true, INFINITE); //等待所有线程安全退出
for (int i = 0; i < Threadnum; i++)
{
CloseHandle(h[i]); //释放内核对象
}
DeleteCriticalSection(&cs); //释放关键段
return 0;
}
unsigned int _stdcall proc(void* argv)
{
//解析参数
Threadarg* parg = (Threadarg*)argv;
volatile int& count = *(parg->p_count);
int* data = parg->p_data;
CRITICAL_SECTION& cs = *(parg->p_cs);
while (count < Questnum) //线程主循环
{
EnterCriticalSection(&cs); //加锁
int n = count;
count += 10;
LeaveCriticalSection(&cs); //解锁
for (int i = 0; i < 10; i++)
{
if (n < Questnum)
{
printf("处理任务%d\n", data[n++]);
}
else
{
break;
}
}
}
return 0;
}
luciferisnotsatan 2013-06-06
- 打赏
- 举报
这都是什么函数。。。[/quote]
都是伪代码
何哀何欢 2013-06-06
- 打赏
- 举报
先把数据用list放，然后线程：
锁定list
从list里pop出10个，
解锁
处理pop出的10个。
不用写2个不同的函数，这一个，开2线程就可以。
buyong 2013-06-06
- 打赏
- 举报
thread pool
宋大小姐 2013-06-06
- 打赏
- 举报
这都是什么函数。。。
宋大小姐 2013-06-06
- 打赏
- 举报
已经申请好200个数据那么大的内存 ，每10个数据一组 ，怎样
每个线程依次从队列que获取一组数据进行处理，直到队列中的数据被处理完？？求代码
luciferisnotsatan 2013-06-06
- 打赏
- 举报
DWORD WINAPI Thread1(LPVOID lpParmeter)
{
while(true)
{
// 获得锁
get10data();
// 释放锁
if(noMoredats);
{
break;
}
deal();
}
return 0;
}
十八道胡同 2013-06-06
- 打赏
- 举报
先把数据放到线程安全的数据结构里，2个thread轮流去读取执行
Longee 2013-06-06
- 打赏
- 举报
将数据每10个分一组，然后保存在队列que中
每个线程依次从队列que获取一组数据进行处理，直到队列中的数据被处理完
