c多線程資料庫

⑴ 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);
}

⑵ linux C下多線程接收數據怎麼進行存儲再統一處理

在Linux系統中使用C/C++進行多線程編程時，我們遇到最多的就是對同一變數的多線程讀寫問題，大多情況下遇到這類問題都是通過鎖機制來處理，但這對程序的性能帶來了很大的影響，當然對於那些系統原生支持原子操作的數據類型來說，我們可以使用原子操作來處理，這能對程序的性能會得到一定的提高。那麼對於那些系統不支持原子操作的自定義數據類型，在不使用鎖的情況下如何做到線程安全呢？本文將從線程局部存儲方面，簡單講解處理這一類線程安全問題的方法。

一、數據類型
在C/C++程序中常存在全局變數、函數內定義的靜態變數以及局部變數，對於局部變數來說，其不存在線程安全問題，因此不在本文討論的范圍之內。全局變數和函數內定義的靜態變數，是同一進程中各個線程都可以訪問的共享變數，因此它們存在多線程讀寫問題。在一個線程中修改了變數中的內容，其他線程都能感知並且能讀取已更改過的內容，這對數據交換來說是非常快捷的，但是由於多線程的存在，對於同一個變數可能存在兩個或兩個以上的線程同時修改變數所在的內存內容，同時又存在多個線程在變數在修改的時去讀取該內存值，如果沒有使用相應的同步機制來保護該內存的話，那麼所讀取到的數據將是不可預知的，甚至可能導致程序崩潰。
如果需要在一個線程內部的各個函數調用都能訪問、但其它線程不能訪問的變數，這就需要新的機制來實現，我們稱之為Static memory local to a thread (線程局部靜態變數)，同時也可稱之為線程特有數據（TSD: Thread-Specific Data）或者線程局部存儲（TLS: Thread-Local Storage）。這一類型的數據，在程序中每個線程都會分別維護一份變數的副本()，並且長期存在於該線程中，對此類變數的操作不影響其他線程。如下圖：

二、一次性初始化
在講解線程特有數據之前，先讓我們來了解一下一次性初始化。多線程程序有時有這樣的需求：不管創建多少個線程，有些數據的初始化只能發生一次。列如：在C++程序中某個類在整個進程的生命周期內只能存在一個實例對象，在多線程的情況下，為了能讓該對象能夠安全的初始化，一次性初始化機制就顯得尤為重要了。——在設計模式中這種實現常常被稱之為單例模式（Singleton）。Linux中提供了如下函數來實現一次性初始化：
#include <pthread.h>

// Returns 0 on success, or a positive error number on error
int pthread_once (pthread_once_t *once_control, void (*init) (void));
利用參數once_control的狀態，函數pthread_once()可以確保無論有多少個線程調用多少次該函數，也只會執行一次由init所指向的由調用者定義的函數。init所指向的函數沒有任何參數，形式如下：
void init (void)
{
// some variables initializtion in here
}
另外，參數once_control必須是pthread_once_t類型變數的指針，指向初始化為PTHRAD_ONCE_INIT的靜態變數。在C++0x以後提供了類似功能的函數std::call_once ()，用法與該函數類似。使用實例請參考https://github.com/ApusApp/Swift/blob/master/swift/base/singleton.hpp實現。

⑶ C#多線程寫資料庫

首先對資料庫（尤其是Access）使用多線程大多不會提高效率（除非SQL中有耗時但不好資源的操作，如T-SQL中休眠之類的語句）。
建議樓主：使用隊列，將要執行的SQL語句放入隊列中（如：System.Collection.Queue或ArrayList），然後用一根線程一條一條執行，另外Access不支持事物回滾只有自己想辦法實現了。濫用多線程會加大程序開發的難度，以及包括程序的不穩定。
另外：cbyvft的答案「……所有的線程使用同一個連接」
，是嚴重錯誤的！！連接對象Connection不能迸發，也就是不能多根李空線程共享一個連接對象，否則很容易引發異常（報錯為：...基礎對象與RAW分離之類的信息）。
若非要用多線程來做，我可以給你一段代碼（我以前開發的項目中一部分），請加我的「網路Hi」並發消息給我，我傳給你。
我不在這里帖代碼了，因為實現的代碼較多，而且比較復雜（使用多線程要哪扮瞎考慮很缺碧多問題，代碼要碩壯通用，所以代碼量較大）。

⑷ 關於C++多線程編程教學

在Windows NT和Windows 9x中，多線程的編程實現需要調用一系列的API函數，如CreateThread、ResumeThread等，比較麻煩而且容易出錯。我們使用Inprise公司的新一代RAD開發工具C＋＋Builder，可以方便地實現多線程的編程。與老牌RAD工具Visual Basic和Delphi比，C＋＋Builer不僅功能非常強大，而且它的編程語言是C＋＋，對於系統開發語言是C的Windows系列操作系統，它具有其它編程語言無可比擬的優勢。利用C＋＋Builder提供的TThread對象，多線程的編程變得非常簡便易用。那麼，如何實現呢？且待我慢慢道來，讓你體會一下多線程櫻配的強大功能。

1. 創建多線程程序：

首先，先介紹一下實現多線程的具體步驟。在C＋＋Builder中雖然用Tthread對象說明了線程的概念，但是Tthread對象本身並不完整，需要在TThread下新建其子類，並重載Execute方法來使用線程對象。在C＋＋Builder下可以很方便地實現這一點。

在C＋＋Builder IDE環境下選擇菜單File|New，在肆李New欄中選中Thread Object，按OK，接下來彈出輸入框，輸入TThread對象子類的名字MyThread，這樣C＋＋Builder自動為你創建了一個名為TMyThread的TThread子類。同時編輯器中多了一個名為Unit2.cpp的單元,這就是我們創建的TMyThread子類脊雹指的原碼，如下：

＃include
＃pragma hdrstop

＃include 「Unit2.h」
＃pragma package(smart_init)
//－－－－－－－－－－－－－－－－－－－－－
// Important: Methods and properties of objects in VCL can only be
// used in a method called using Synchronize, for example:
//
// Synchronize(UpdateCaption);
//
// where UpdateCaption could look like:
//
// void __fastcall MyThread::UpdateCaption()
// {
// Form1－>Caption = 「Updated in a thread」;
// }
//－－－－－－－－－－－－－－－－－－－－
__fastcall MyThread::MyThread(bool CreateSuspended)
: TThread(CreateSuspended)
{
}
//－－－－－－－－－－－－－－－－－－－－
void __fastcall MyThread::Execute()
{
//－－－－ Place thread code here －－－－
}
//－－－－－－－－－－－－－－－－－－－－－

其中的Execute（）函數就是我們要在線程中實現的任務的代碼所在處。在原代碼中包含Unit2.cpp，這個由我們創建的TMyThread對象就可以使用了。使用時，動態創建一個TMyThread 對象，在構造函數中使用Resume（）方法，那麼程序中就增加了一個新的我們自己定義的線程TMyThread，具體執行的代碼就是Execute（）方法重載的代碼。要載入更多的線程，沒關系，只要繼續創建需要數量的TMyThread 對象就成。

⑸ C語言多線程的操作步驟

線程創建
函數原型：intpthread_create(pthread_t*restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void),void *restrict arg);
返回值：若是成功建立線程返回0，否則返回錯誤的編號。
形式參數：_t*restrict tidp要創建的線程的線程id指針；const pthread_attr_t *restrict attr創建線程時的線程屬性；void *(start_rtn)(void)返回值是void類型的指針函數；void *restrict arg start_rtn的形參。
線程掛起：該函數的作用使得當前線程掛起，等待另一個線程返回才繼續執行。也就是說當程序運行到這個地方時，程序會先停止，然後等線程id為thread的這個線程返回，然後程序才會斷續執行。
函數原型：intpthread_join(pthread_tthread, void **value_ptr);
參數說明如下：thread等待退出線程的線程號；value_ptr退出線程的返回值。
返回值：若成功，則返回0；若失敗，則返回錯誤號。
線程退出
函數原型：voidpthread_exit(void *rval_ptr);
獲取當前線程id
函數原型：pthread_tpthread_self(void);
互斥鎖
創建pthread_mutex_init；銷毀pthread_mutex_destroy；加鎖pthread_mutex_lock；解鎖pthread_mutex_unlock。
條件鎖
創建pthread_cond_init；銷毀pthread_cond_destroy；觸發pthread_cond_signal；廣播pthread_cond_broadcast；等待pthread_cond_wait。