① 多线程cpu有什么好处
CPU多线程简称SMT，可通过复制处理器上的结构状态，让同一个处理器上的多个线程同步执行并共享处理器的执行资源，可最大限度地实现宽发射、乱序的超标量处理，提高处理器运算部件的利用率，缓和由于数据相关或Cache未命中带来的访问内存延时。
注：当没有多个线程可用时，SMT处理器几乎和传统的宽发射超标量处理器一样。
cpu的多线程技术可以为高速的运算核心准备更多的待处理数据，减少运算核心的闲置时间；解决了负载均衡问题，充分利用了CPU资源，提高CPU的使用率。采用多线程的方式可以同时完成几件事情而不互相干扰，缩短了处理大量的IO操作时或处理的情况需要花费大量的时间。
多线程的好处：
1、使用线程可以把占据时间长的程序中的任务放到后台去处理
2、用户界面更加吸引人,这样比如用户点击了一个按钮去触发某件事件的处理,可以弹出一个进度条来显示处理的进度
3、程序的运行效率可能会提高
4、在一些等待的任务实现上如用户输入,文件读取和网络收发数据等,线程就比较有用了.
多线程的缺点：
1、如果有大量的线程,会影响性能,因为操作系统需要在它们之间切换.
2、更多的线程需要更多的内存空间
3、线程中止需要考虑对程序运行的影响.
4、通常块模型数据是在多个线程间共享的,需要防止线程死锁情况的发生
② c++数据库那种最快,支持多线程,或文本数据库
选择成品数据库，要看之后的应用结构的才能确定用哪个快..
如果仅仅是要写入时快，不考虑查询情况..那当然直接把C/C++的数据结构给保存了最快..
比如保存一个struct Record，或class Record，限定好成员大小后，直接内存到磁盘的写盘...
这样写最快，而读取只能顺序读取....
另json等是交换格式不是存储格式更不能当数据库用哇....
③ C#多线程写数据库
首先对数据库（尤其是Access）使用多线程大多不会提高效率（除非sql中有耗时但不好资源的操作，如T-SQL中休眠之类的语句）。
建议楼主：使用队列，将要执行的SQL语句放入队列中（如：System.Collection.Queue或ArrayList），然后用一根线程一条一条执行，另外Access不支持事物回滚只有自己想办法实现了。滥用多线程会加大程序开发的难度，以及包括程序的不稳定。
另外：cbyvft的答案“……所有的线程使用同一个连接”
，是严重错误的！！连接对象Connection不能迸发，也就是不能多根线程共享一个连接对象，否则很容易引发异常（报错为：...基础对象与RAW分离之类的信息）。
若非要用多线程来做，我可以给你一段代码（我以前开发的项目中一部分），请加我的“网络Hi”并发消息给我，我传给你。
我不在这里帖代码了，因为实现的代码较多，而且比较复杂（使用多线程要考虑很多问题，代码要硕壮通用，所以代码量较大）。
④ C/C++多线程问题
WINDOWS线程需要这样的函数体：
DWORD WINAPI thread_proc(LPVOID lpParam)
{
...
return 0;
}
C语言中直接调用线程就是CreateThread(&thread_proc, ...)即可
因为C++的类是在运行阶段分配地址，而不是在编译阶段分配地址，所以要想在类函数中声明线程，就必须强制把线程成员函数设置为编译阶段就分配地址，这样才能绑定到WINDOWS API的CreateThread函数上去，这种方式叫做static.
之所以保存线程指针是因为现代多任务操作系统往往处于比较复杂的状态。比如，假设你的线程是用于下载某个网络资源，如电影等；同时网络用户调整了带宽，或者开始打游戏，或者播放视频，这些都会影响CPU对当前定义的线程的资源控制。如果线程内部涉及了很多资源，如果不进行善后则后果比较严重（假设你的线程在下一个电影的局部片段，因为资源没有正常退出，导致整个电影文件即使全部下载下来也无法打开）。所以为了妥善处理，一般好的软件在主程序接到退出、终止、异常时，首先都会尝试【安全】退出线程，逐步关闭已打开的资源，如文件、数据库、管道、网络连接等等，再彻底退出。
假如你的线程用于网络游戏，那就更典型了，你不希望因为一时断网，导致下次再上的时候，装备全丢吧？
⑤ C# 多线程 大量数据实时接收\解析\存储 问题
1、定义两个线程安全的队列（System.Collections.Concurrent.ConcurrentQueue<T>）a跟b，其中a用于储存接受的数据，b用于储存要持久化的数据。
2、线程A循环读取数据并储存到队列a中。
3、线程B循环从队列a中读取数据。
3.1、如果读取到数据
3.1.1、将解析前的数据跟解析后的数据赋值给专门储存它们的类c。
3.1.2、将类c添加到队列b中。
3.1.3、将解析后的数据显示到UI线程中。
3.2、如果没有读取到数据，则sleep一定时间。
4、线程C循环从队列b中读取数据。
4.1、如果读取到数据，则储存数据。
4.2、如果没有读取到数据，则sleep一定时间。
5、线程D可以不要，不过假设数据的处理时间过长，将导致队列长度不断增长，所以线程D可以循环判断队列a跟队列b的长度。假设队列中的对象数量超过特定阀值，则进行一定处理。比如终止程序，比如跳过部分数据，比如停止接收数据等。
⑥ C语言，OCI多线程建立session的问题，需要一个多线程连接的示例代码
。。
你子线程控制同步了么？ 断错误一般是内存操作出错 和oci 或者pthread的关系不大！
void* OracleProcess(GPS_DATA GpsRec) // 数据库数据处理
{
interval = 0;
struct HashItem* pHash;
pHash = inithashtable(MAX_REC<<2);
char sql[384] = {0};
char temp[256] = {0};
char tName[10] = {0}; // 表名字
int i,k;
int j = TotalRec >> RATE;
double distance;
for(i=0; i < j; i++)
{
sprintf(temp,"%s%f%f%f%d",gps_last[i].tid,gps_last[i].lon,gps_last[i].lat,gps_last[i].speed,gps_last[i].udate);
InsertHash(temp, pHash, MAX_REC<<2); // 插入最后GPS信息到hash
memset(temp,0x00,256);
}
for(i = 0; i < TotalRec; i++)
{
for(k=0; k<j; k++) // 查询车机是否在册
if(strcmp(GpsRec[i].tid,tid[k]) == 0)
break;
if(k < j)
{
if(GpsRec[i].udate != 0.00)
{
distance = InfoUpdate(GpsRec,i); // 最新GPS数据更新
sprintf(temp,"%s%f%f%f%d",GpsRec[i].tid,GpsRec[i].lon,GpsRec[i].lat,GpsRec[i].speed,GpsRec[i].udate);
if(GetHashTablePos(temp, pHash, MAX_REC<<2) == -1) // 查找hash是否存在
{
if (distance > 0.0001)
{
sprintf(tName,"GPS_%d_Y",tf[k]);
InsertHash(temp, pHash, MAX_REC<<2); // 插入
sprintf(sql,"insert into %s (id,tm_id,lon,lat, speed, utc_time, udate,mileage,DIRECTION,DISTANCE) values (seq_gps.nextVal,'%s','%f','%f','%f','%d','%d','%f','%d','%f','%d')",
tName,GpsRec[i].tid,GpsRec[i].lon,GpsRec[i].lat,GpsRec[i].speed,GpsRec[i].utime,GpsRec[i].udate,GpsRec[i].mileage,GpsRec[i].dir,distance,interval);
printf("%s\n",sql);
oci_excu(oracle_env,(text *)sql,0); // 插入数据
memset(tName,0x00,10);
}
}
memset(sql,0x00,384);
memset(temp,0x00,256);
}
}
}
memset(GpsRec,0x00,sizeof(GpsRec));
free(pHash);
pthread_exit(NULL);
}
void TcpProcess(int tfd) // 处理TCP连接上的事务
{
struct timeval ntime;
int index = 0,times,ret;
int rlen = 0,rflag = 0;
char recvbuf[513] = {0};
bzero(recvbuf,513);
while(1)
{
ret = rlen = read(tfd,recvbuf,512);
if(rlen <= 0)
break;
if((rlen%32) == 0) // 32长度为标准TCP信息
{
times = 0;
ret >>= 5;
while(ret--)
{
if(tflag[tfd] == tfd) // 已经存在的socket
{
LOVENIX *info = (LOVENIX *)malloc(sizeof(LOVENIX));
memset(info,0x00,sizeof(LOVENIX));
if(recvbuf[times] == 0x58 || recvbuf[times] == 0x59)
ProtocolAnalysisLovenixTcp(&recvbuf[times],info);
else if(recvbuf[times] == 0x24)
ProtocolAnalysisLovenixUdp(&recvbuf[times],info);
sprintf(info->tid,"%s",seq[tfd]); // 合成车辆ID
DataProcess(info); // 处理GPS数据
free(info);
gettimeofday(&ntime, NULL);
cntime[tfd] = ntime.tv_sec; // 更新时间
times += 32;
}
}
}
else if(rlen > 32)
{
if(!rflag)
{
if((index = RegLovenix(tfd,recvbuf)) > -1)
{
sprintf(seq[tfd],"%s",tid[index]); // 将对应的socket设备ID保存
gettimeofday(&ntime, NULL);
sfd[tfd] = tfd;
cntime[tfd] = ntime.tv_sec;
tflag[tfd] = tfd;
rflag = 1;
}
}
}
if(rlen < 512); // 已经读完
break;
memset(recvbuf,0x00,rlen);
}
}
void *TcpServer(void *arg)
{
int port = (unsigned int) arg;
int efd,i;
struct timeval ntime;
int listener, nfds, n, listen_opt = 1, lisnum;
struct sockaddr_in my_addr, their_addr;
socklen_t len = sizeof(their_addr);
lisnum = MAXLISTEN;
for(i=0; i<MAX_REC; i++)
{
sfd[i] = 0;
tflag[i] = 0;
}
if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) // 开启 socket 监听
{
lprintf(lfd, FATAL, "TCP Socket error!\n");
exit(1);
}
else
lprintf(lfd, INFO, "TCP socket creat susscess！\n");
setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (void *) &listen_opt,(int) sizeof(listen_opt)); // 设置端口多重邦定
setnonblocking(listener);
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(port);
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)
{
lprintf(lfd, FATAL, "TCP bind error!\n");
exit(1);
}
else
lprintf(lfd, INFO, "TCP bind susscess!\n");
if (listen(listener, lisnum) == -1)
{
lprintf(lfd, FATAL, "TCP listen error!\n");
exit(1);
}
else
lprintf(lfd, INFO, "TCP listen susscess!\n");
kdpfd = epoll_create(MAXEPOLLSIZE); // 创建 epoll句柄，把监听socket加入到epoll集合里
ev.events = EPOLLIN | EPOLLET; // 注册epoll 事件
ev.data.fd = listener;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)
lprintf(lfd, FATAL, "EPOLL_CTL_ADD error!\n");
while (1)
{
sem_wait(&sem_tcp); // 等待 sem_TCP
sem_wait(&sem_tp); // 将tp值减一
nfds = epoll_wait(kdpfd, events, MAXEPOLLSIZE, 1); // 等待有事件发生
if (nfds == -1)
lprintf(lfd, FATAL,"EPOLL_WAIT error!\n");
for (n = 0; n < nfds; ++n) // 处理epoll所有事件
{
if (events[n].data.fd == listener) // 如果是连接事件
{
if ((efd = accept(listener, (struct sockaddr *) &their_addr,&len)) < 0)
{
lprintf(lfd, FATAL, "accept error!\n");
continue;
}
else
lprintf(lfd, INFO, "Client from ：%s\tSocket ID:%d\n", inet_ntoa(their_addr.sin_addr) ,efd);
setnonblocking(efd); // 设置新连接为非阻塞模式
ev.events = EPOLLIN | EPOLLET; // 注册新连接
ev.data.fd = efd;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, efd, &ev) < 0) // 将新连接加入EPOLL的监听队列
lprintf(lfd, FATAL, "EPOLL_CTL_ADD error!\n");
else
{
gettimeofday(&ntime, NULL);
cntime[efd] = ntime.tv_sec;
sfd[efd] = efd;
}
}
else if (events[n].events & EPOLLIN)
tpool_add_work(pool, TcpProcess, (void*)events[n].data.fd); // 读取分析TCP信息
else
{
close(events[n].data.fd);
epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
}
}
sem_post(&sem_cm);
sem_post(&sem_udp);
}
close(listener);
}
int DataProcess(LOVENIX *info) // 处理GPS数据
{
if(sflag == 0 && (CacheRec != TotalRec)) // 缓存1可用且没有满
{
gps_cache[CacheRec].lat = info->lat;
gps_cache[CacheRec].mileage = info->mileage;
gps_cache[CacheRec].lon = info->lon;
gps_cache[CacheRec].speed = atod(info->speed, strlen(info->speed))*0.514444444*3.6;
gps_cache[CacheRec].udate = atoi(info->udate);
gps_cache[CacheRec].utime = atoi(info->utime);
gps_cache[CacheRec].dir = atoi(info->dir);
sprintf(gps_cache[CacheRec].tid ,"%s",info->tid);
CacheRec++;
// printf("CacheRec %d\tTotalRec %d \t sflag:%d\n",CacheRec,TotalRec,sflag);
if(CacheRec == TotalRec)
{
sflag = 1;
pthread_attr_init(&attr); // 初始化属性值，均设为默认值
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 设置线程为分离属性
if (pthread_create(&thread, &attr,(void*) OracleProcess,(void*)gps_cache)) // 创建数据处理线程
lprintf(lfd, FATAL, "oracle pthread_creat error!\n");
CacheRec = 0;
}
}
else if(sflag == 1 && (Cache1Rec != TotalRec)) // 缓存2可用且没有满
{
gps_cache1[Cache1Rec].mileage = info->mileage;
gps_cache1[Cache1Rec].lat = info->lat;
gps_cache1[Cache1Rec].lon = info->lon;
gps_cache1[Cache1Rec].speed = atod(info->speed, strlen(info->speed))*0.514444444*3.6;
gps_cache1[Cache1Rec].udate = atoi(info->udate);
gps_cache1[Cache1Rec].utime = atoi(info->utime);
gps_cache1[Cache1Rec].dir = atoi(info->dir);
sprintf(gps_cache1[Cache1Rec].tid ,"%s",info->tid);
Cache1Rec++;
if(Cache1Rec == TotalRec)
{
sflag = 0;
pthread_attr_init(&attr); // 初始化属性值，均设为默认值
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 设置线程为分离属性
if (pthread_create(&thread, &attr,(void*) OracleProcess,(void*)gps_cache1)) // 创建数据处理线程
lprintf(lfd, FATAL, "oracle pthread_creat error!\n");
Cache1Rec = 0;
}
}
else
{
lprintf(lfd, FATAL, "No cache to use!\n");
return (0);
}
return (1);
}
⑦ C语言如何实现多线程同时运行
1、点击菜单栏的“Project”选项卡，下拉列表的最后一项“Project options...”是对当前工程的的属性进行设置的。
⑧ C/C++用一个连接多线程并发访问数据库会不会有问题
加个原子锁吧，尽量异步访问
⑨ 多线程并发访问数据库并同时开启事务的情况下，可能产生的问题包括
AB
C不是问题，C是可重复读隔离级别下的一个正常现象。
⑩ 用pro*c/c++ 和qt creator工具让C++连接Oracle数据库的问题。
数据库连接作为一种资源，我们的应用必须对之进行行之有效的管理。我们在访问数据库的时候，一般传统上采用先建立连接，然后使用该连接访问数据库，在使用完毕后，关闭该连接。这是我们经常采用的方法。该方法的好处是使用简单，不用对连接进行任何管理。但随之带来的缺点也就出现了，在应用需要频繁访问数据库的时候，这种方法就会使程序的效率十分低下，甚至有时候是不能满足应用的需要的。随着数据库连接池技术出现了，我们的应用根据访问数据库的频率动态决定创建连接的数量，以及决定在适当的时刻可以关闭一些数据库连接，用以节省这种资源。笔者最近在参考了网上大量代码的同时，实现了如何利用Pro C++使用数据库连接池完成了多线程对oracle数据库的访问。本着来源于网络，共享与网络的精神，和大家共同探讨，其中笔者的大部分代码来源是黄剑锋先生的共享代码，在此深表感谢。实现的基本功能如下：1：可以设定最小的数据库连接数。2：可以设定最大的数据库连接数。3：当数据库某个连接空闲时间多长时间后，该连接池会自动断开连接以节省数据库连接资源。4：提供了每个连接被使用的次数接口，方便统计和分析各个连接的情况。5：提供了每个连接从上次访问完毕，懂查看的时候为止，已经空闲的时长，以秒为单位。6：可以动态访问数据库存储过程，即存储过程的名字可以动态变化的。
代码库：http://blog.csdn.net/wayneforever/article/details/9028901
望采纳，谢谢