c語言windows多線程
㈠ 線程之間的通信例子 求一個WINDOWS下多線程間通信的例子，用c語言編寫！
#include
<stdio.h>
int
main(int
argc,
char
**argv){
CreateThread(NULL,
0,
thread2,
this,
0,
0);
printf("主線程正在執行！\n");
return
0;
}
void
thread2(){
sleep(2);//睡2毫秒
printf("第二個線程在運行！\n");
}
這個例子可能很簡單，但能說明問題了。
㈡ C語言，windows多線程編程
點量Http、FTP多線程斷點續傳下載組件（下載DLL）的開發目的是讓用戶可以無需關心Http/FTP協議的具體細節，只需要幾十行甚至幾行代碼，便可以實現一個功能完善的Http/FTP下載軟體。點量Http/FTP下載組件（DLL）支持多線程、斷點續傳、顯示詳細下載過程、自動查找鏡像網址、支持代理傳輸等完善的功能。
點量Http、FTP下載內核源碼使用高效的c++代碼編寫，提供標準的動態鏈接庫（DLL），可供C/C++、Delphi、C#、Java、VB等語言和各常用開發環境調用，讓您完全像調用系統API一樣的調用。
點量Http/FTP組件的功能簡介：
標准Http和FTP下載支持：完全標準的Http和FTP協議支持，內部通過網址自動區分是Http還是FTP下載。
極速下載（2.0以後版本）：超越國內絕大多數下載軟體的下載速度。新版內核在2M ADSL的環境下下載，有些文件的速度可以達到1400K位元組/秒以上，超過了帶寬的極限。下載速度可以用極速形容。
多線程傳輸：可以將文件自動分塊，並採用多線程下載。並可自由設置線程數目。
斷點續傳：點量Http/FTP有優秀的斷點續傳支持，每次啟動自動從上次下載的位置開始，不需要重復下載。
提供詳細的下載詳情介面（2.0以後版本）：可以看到整個下載過程的步驟，比如開啟了多少線程、伺服器的應答過程、錯誤信息等。
支持多種高級設置：設置線程數目、磁碟緩存大小、搜索鏡像伺服器的詳細參數設置、下載文件完成後同步文件為伺服器上的文件時間、下載過程中可以自定義文件臨時後綴、未完成的文件設為隱藏屬性。
支持磁碟緩存：點量Http/FTP下載DLL支持設置磁碟緩存，減少對磁碟的讀寫，並提升下載速度。
支持設置Refer：點量Http/FTP下載組件支持設置下載時的Refer，以便可以繞過一些防盜鏈的網站，直接下載內容。
限速功能：點量Http/FTP下載組件可方便的設置下載限速。
多種磁碟分配方式：點量Http/FTP下載組件支持預分配和邊下載邊分配兩種磁碟方式，滿足多種下載需求。
自動搜索鏡像加速：點量Http/FTP內置了鏡像搜索功能，在下載文件的同時，會自動搜索哪些其它網站還有這個文件，自動從其它網址下載加速。
可提供源碼：支付一定的費用，便可以獲得全部的點量Http/FTP下載組件的源代碼，免除您的所有後顧之憂。
良好的服務：作為點量軟體旗下的軟體，可享受到點量軟體的優秀服務，我們的服務讓您如同擁有一個稱心的專業員工。
點量Http/FTP 下載組件可以適用於任何Http和FTP下載的領域，讓您可以在1天內完成一個完整的Http下載軟體的全部功能。比如，您可以用於產品的升級、文件的下載和傳輸等。
點量Http/FTP內核可以為您帶來：
1、大大節省您的開發成本：了解Http和FTP的協議，再去編碼、測試，即使對於一個非常有經驗的開發人員來說，也需要較長期的時間，此間耗費的人力資源成本和管理成本可謂不少。而使用點量Http/FTP，您就不需要從製造輪子開始製造您的汽車，將注意力集中於車的設計而不是基礎設備的建設。何況我們的產品性能是如此優越！
2、強有力的技術支持：作者長期從事下載技術的研發，所提供的技術支持相當於您僱傭了一位具有豐富經驗，無需從頭學習的開發人員，可以在您的系統建設過程中為您提供整體系統架設的意見。
如果您是個人作為非商業目的使用，您可以自由、免費的使用點量Http/FTP下載組件內核庫和演示程序，也期待收到您反饋的意見和建議；如果您是商業使用，那麼您需要聯系作者申請產品的商業授權。
㈢ C語言能實現多線程么
可以，在Windows下面，用CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreateionFlags,
LPDWORD lpThreadId)
函數可以創建一個線程,第一個參數指線程的安全屬性的設定，第二個參數表示線程堆棧的大小，第三個參數表示線程函數名稱，第四個參數線程執行的參數，第五個參數指線程的優先順序，最後一個參數指向線程的ID。關於windows下用C創建多線程可以查查MSDN即可。
如果還是不懂的話，建議樓主先弄懂計算機操作系統的原理，或者弄懂計算機線程與進程的異同與關系
㈣ C語言怎樣實現多線程
首先你要有控制蛇移動方向的全局變數（定義在main以外因為線程函數也要調用它，每次鍵盤輸入都會修改它的值）， 比如 char direction 'a' ==左 'w' == 右 'd'==上 's' == 下，然後你在移動時應該是在while裡面操作的吧，你每移動一步前都讀一下direction這個變數的數值然後再控制移動方向（注意s這個鍵可以忽略因為不會倒著走） 然後你可以用pthread.h這個庫 例子是 pthread t;// 定義一個線程 pthread_create(&t, null, listen_keyboard_input, null);//建立線程執行listen_keyboard_input這個函數 這個線程執行的函數 void listen_keyboard_input(){ while(應該通過某個信號來退出這個循環，從而表示游戲結束){ direction =getchar(); } } 但是這里存在同步問題， 比如當這個線程的getchar（）在給direction輔助的同時，你控制貪吃蛇移動的線程正在調用 direction的值來判斷下一個移動方向，這就會出問題，所以要加一個鎖，叫 mutex lock;這個也定義成全局變數可以使各線程共享。 pthread_mutex_t mutex; //定義一個鎖 pthread_mutex_init(&mutex, null, null);//初始化 然後把函數修改成 void listen_keyboard_input(){ while(應該通過某個信號來退出這個循環，從而表示游戲結束){ pthread_mutex_lock(&mutex); direction =getchar(); pthread_mutex_unlock(&mutex); } } 另外一個控制貪吃蛇移動的時候也要加鎖 while(.....){ char c; pthread_mutex_lock(&mutex); c = direction; pthread_mutex_unlock(&mutex); switch(c){ ................ } ................................... } 這樣就好了 注意你的控制貪吃蛇移動的部分也必須要放在另外一個pthread 裡面執行，如果放在主線程， 主線程會一直等listen_keyboard_input而什麼事都不會做 你把這兩個線程用 pthread_create 創建完成後 用 t1.join(); t2.join(); 就可以使這兩個線程並發執行了 如果你用的是linux 來編譯的，你再輸入gcc 指令後加上 -lpthread 就可以了 還有什麼不懂的你可以多找找 pthread 類的例子
㈤ C語言如何實現多線程同時運行
1、點擊菜單欄的「Project」選項卡，下拉列表的最後一項「Project options...」是對當前工程的的屬性進行設置的。
㈥ 請問用C語言在windows上建立多線程需要用什麼函數最好，
#include<windows.h>
#include<fstream.h>
#include<stdio.h>
#include<string>
#include<conio.h>
//定義一些常量；
//本程序允許的最大臨界區數；
#define MAX_BUFFER_NUM 10
//秒到微秒的乘法因子；
#define INTE_PER_SEC 1000
//本程序允許的生產和消費線程的總數；
#define MAX_THREAD_NUM 64
//定義一個結構，記錄在測試文件中指定的每一個線程的參數
struct ThreadInfo
{
int serial; //線程序列號
char entity; //是P還是C
double delay; //線程延遲
int thread_request[MAX_THREAD_NUM]; //線程請求隊列
int n_request; //請求個數
};
//全局變數的定義
//臨界區對象的聲明,用於管理緩沖區的互斥訪問；
CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM];
int Buffer_Critical[MAX_BUFFER_NUM]; //緩沖區聲明，用於存放產品；
HANDLE h_Thread[MAX_THREAD_NUM]; //用於存儲每個線程句柄的數組；
ThreadInfo Thread_Info[MAX_THREAD_NUM]; //線程信息數組；
HANDLE empty_semaphore; //一個信號量；
HANDLE h_mutex; //一個互斥量；
DWORD n_Thread = 0; //實際的線程的數目；
DWORD n_Buffer_or_Critical; //實際的緩沖區或者臨界區的數目；
HANDLE h_Semaphore[MAX_THREAD_NUM]; //生產者允許消費者開始消費的信號量；
//生產消費及輔助函數的聲明
void Proce(void *p);
void Consume(void *p);
bool IfInOtherRequest(int);
int FindProcePositon();
int FindBufferPosition(int);
int main(void)
{
//聲明所需變數；
DWORD wait_for_all;
ifstream inFile;
//初始化緩沖區；
for(int i=0;i< MAX_BUFFER_NUM;i++)
Buffer_Critical[i] = -1;
//初始化每個線程的請求隊列；
for(int j=0;j<MAX_THREAD_NUM;j++){
for(int k=0;k<MAX_THREAD_NUM;k++)
Thread_Info[j].thread_request[k] = -1;
Thread_Info[j].n_request = 0;
}
//初始化臨界區；
for(i =0;i< MAX_BUFFER_NUM;i++)
InitializeCriticalSection(&PC_Critical[i]);
//打開輸入文件，按照規定的格式提取線程等信息；
inFile.open("test.txt");
//從文件中獲得實際的緩沖區的數目；
inFile >> n_Buffer_or_Critical;
inFile.get();
printf("輸入文件是:\n");
//回顯獲得的緩沖區的數目信息；
printf("%d \n",(int) n_Buffer_or_Critical);
//提取每個線程的信息到相應數據結構中；
while(inFile){
inFile >> Thread_Info[n_Thread].serial;
inFile >> Thread_Info[n_Thread].entity;
inFile >> Thread_Info[n_Thread].delay;
char c;
inFile.get(c);
while(c!='\n'&& !inFile.eof()){
inFile>> Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request++];
inFile.get(c);
}
n_Thread++;
}
//回顯獲得的線程信息，便於確認正確性；
for(j=0;j<(int) n_Thread;j++){
int Temp_serial = Thread_Info[j].serial;
char Temp_entity = Thread_Info[j].entity;
double Temp_delay = Thread_Info[j].delay;
printf(" \n thread%2d %c %f ",Temp_serial,Temp_entity,Temp_delay);
int Temp_request = Thread_Info[j].n_request;
for(int k=0;k<Temp_request;k++)
printf(" %d ", Thread_Info[j].thread_request[k]);
cout<<endl;
}
printf("\n\n");
//創建在模擬過程中幾個必要的信號量
empty_semaphore=CreateSemaphore(NULL,n_Buffer_or_Critical,n_Buffer_or_Critical,
"semaphore_for_empty");
h_mutex = CreateMutex(NULL,FALSE,"mutex_for_update");
//下面這個循環用線程的ID號來為相應生產線程的產品讀寫時所
//使用的同步信號量命名；
for(j=0;j<(int)n_Thread;j++){
std::string lp ="semaphore_for_proce_";
int temp =j;
while(temp){
char c = (char)(temp%10);
lp+=c;
temp/=10;
}
h_Semaphore[j+1]=CreateSemaphore(NULL,0,n_Thread,lp.c_str());
}
//創建生產者和消費者線程；
for(i =0;i< (int) n_Thread;i++){
if(Thread_Info[i].entity =='P')
h_Thread[i]= CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Proce),
&(Thread_Info[i]),0,NULL);
else
h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consume),
&(Thread_Info[i]),0,NULL);
}
//主程序等待各個線程的動作結束；
wait_for_all = WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);
printf(" \n \nALL Procer and consumer have finished their work. \n");
printf("Press any key to quit!\n");
_getch();
return 0;
}
//確認是否還有對同一產品的消費請求未執行；
bool IfInOtherRequest(int req)
{
for(int i=0;i<n_Thread;i++)
for(int j=0;j<Thread_Info[i].n_request;j++)
if(Thread_Info[i].thread_request[j] == req)
return TRUE;
return FALSE;
}
//找出當前可以進行產品生產的空緩沖區位置；
int FindProcePosition()
{
int EmptyPosition;
for (int i =0;i<n_Buffer_or_Critical;i++)
if(Buffer_Critical[i] == -1){
EmptyPosition = i;
//用下面這個特殊值表示本緩沖區正處於被寫狀態；
Buffer_Critical[i] = -2;
break;
}
return EmptyPosition;
}
//找出當前所需生產者生產的產品的位置；
int FindBufferPosition(int ProPos)
{
int TempPos;
for (int i =0 ;i<n_Buffer_or_Critical;i++)
if(Buffer_Critical[i]==ProPos){
TempPos = i;
break;
}
return TempPos;
}
//生產者進程
void Proce(void *p)
{
//局部變數聲明；
DWORD wait_for_semaphore,wait_for_mutex,m_delay;
int m_serial;
//獲得本線程的信息；
m_serial = ((ThreadInfo*)(p))->serial;
m_delay = (DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);
Sleep(m_delay);
//開始請求生產
printf("Procer %2d sends the proce require.\n",m_serial);
//確認有空緩沖區可供生產，同時將空位置數empty減1；用於生產者和消費者的同步；
wait_for_semaphore = WaitForSingleObject(empty_semaphore,-1);
//互斥訪問下一個可用於生產的空臨界區，實現寫寫互斥；
wait_for_mutex = WaitForSingleObject(h_mutex,-1);
int ProcePos = FindProcePosition();
ReleaseMutex(h_mutex);
//生產者在獲得自己的空位置並做上標記後，以下的寫操作在生產者之間可以並發；
//核心生產步驟中，程序將生產者的ID作為產品編號放入，方便消費者識別;
printf("Procer %2d begin to proce at position %2d.\n",m_serial,ProcePos);
Buffer_Critical[ProcePos] = m_serial;
printf("Procer %2d finish procing :\n ",m_serial);
printf(" position[ %2d ]:%3d \n" ,ProcePos,Buffer_Critical[ProcePos]);
//使生產者寫的緩沖區可以被多個消費者使用，實現讀寫同步；
ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL);
}
//消費者進程
void Consume(void * p)
{
//局部變數聲明；
DWORD wait_for_semaphore,m_delay;
int m_serial,m_requestNum; //消費者的序列號和請求的數目；
int m_thread_request[MAX_THREAD_NUM];//本消費線程的請求隊列；
//提取本線程的信息到本地；
m_serial = ((ThreadInfo*)(p))->serial;
m_delay = (DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);
m_requestNum = ((ThreadInfo *)(p))->n_request;
for (int i = 0;i<m_requestNum;i++)
m_thread_request[i] = ((ThreadInfo*)(p))->thread_request[i];
Sleep(m_delay);
//循環進行所需產品的消費
for(i =0;i<m_requestNum;i++){
//請求消費下一個產品
printf("Consumer %2d request to consume %2d proct\n",m_serial,m_thread_request[i]);
//如果對應生產者沒有生產，則等待；如果生產了,允許的消費者數目-1；實現了讀寫同步；
wait_for_semaphore=WaitForSingleObject(h_Semaphore[m_thread_request[i]],-1);
//查詢所需產品放到緩沖區的號
int BufferPos=FindBufferPosition(m_thread_request[i]);
//開始進行具體緩沖區的消費處理，讀和讀在該緩沖區上仍然是互斥的；
//進入臨界區後執行消費動作；並在完成此次請求後，通知另外的消費者本處請求已
//經滿足；同時如果對應的產品使用完畢，就做相應處理；並給出相應動作的界面提
//示；該相應處理指將相應緩沖區清空，並增加代表空緩沖區的信號量；
EnterCriticalSection(&PC_Critical[BufferPos]);
printf("Consumer%2d begin to consume %2d proct \n",m_serial,m_thread_request[i]);
((ThreadInfo*)(p))->thread_request[i] =-1;
if(!IfInOtherRequest(m_thread_request[i])){
Buffer_Critical[BufferPos] = -1;//標記緩沖區為空；
printf("Consumer%2d finish consuming %2d:\n ",m_serial,m_thread_request[i]);
printf(" position[ %2d ]:%3d \n" ,BufferPos,Buffer_Critical[BufferPos]);
ReleaseSemaphore(empty_semaphore,1,NULL);
}
else{
printf("Consumer %2d finish consuming proct %2d\n ",m_serial,m_thread_request[i]);
}
//離開臨界區
LeaveCriticalSection(&PC_Critical[BufferPos]);
}
}
看函數就行
㈦ c語言中怎樣創建多線程
/*這是我寫的最簡單的多線程程序，看懂不？*/
#include <windows.h>
#include <stdio.h>
//#include <strsafe.h>
DWORD WINAPI ThreadProc1( LPVOID lpParam )
{
int i=0,j=0;
while(1)
{
printf("hello,this thread 1 ...\n");
//延時
for(i=0;i<200000000;i++)
{
;
}
}
}
DWORD WINAPI ThreadProc2( LPVOID lpParam )
{
int i=0,j=0;
while(1)
{
printf("hello,this thread 2 ...\n");
//延時
for(i=0;i<200000000;i++)
{
;
}
}
}
void main()
{
int i=0;
//創建線程1
CreateThread(
NULL, // default security attributes
0, // use default stack size
ThreadProc1, // thread function
NULL, // argument to thread function
0, // use default creation flags
NULL); // returns the thread identifier
//創建線程2
CreateThread(
NULL, // default security attributes
0, // use default stack size
ThreadProc2, // thread function
NULL, // argument to thread function
0, // use default creation flags
NULL); // returns the thread identifier
//讓主線程進入循環，主線程若退出，子線程1，2會被系統「殺死」
while(1)
{
printf("hello,this thread 0 ...\n");
//延時
for(i=0;i<200000000;i++)
{;}
}
}
㈧ c語言多線程問題
#include <stdio.h>
#include <process.h>
#include <windows.h>
long g_nNum; //全局資源
unsigned int __stdcall Fun(void *pPM); //線程函數
const int THREAD_NUM = 10; //子線程個數
int main()
{
g_nNum = 0;
HANDLE handle[THREAD_NUM];
int i = 0;
while (i < THREAD_NUM)
{
handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);
i++;//等子線程接收到參數時主線程可能改變了這個i的值
}
//保證子線程已全部運行結束
WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);
return 0;
}
unsigned int __stdcall Fun(void *pPM)
{
//由於創建線程是要一定的開銷的，所以新線程並不能第一時間執行到這來
int nThreadNum = *(int *)pPM; //子線程獲取參數
Sleep(75);//some work should to do
g_nNum++; //處理全局資源
Sleep(1);//some work should to do
printf("線程編號為%d 全局資源值為%d\n", nThreadNum, g_nNum);
getch();
return 0;
}
㈨ windows環境，多線程情況下，C語言向文件寫入數據。
下面的程序，編譯之後，你可以運行很多個實例，目前我將文件寫在了D:\1.txt，每個程序寫1000行數據，這些值你可以自己更改（比如 寫在C:，每個程序寫10000行等），等程序都寫完後，你可以去文件中查看寫文件的結果。補充一下，我是在VC6.0環境中寫的，所以windows.h，如果你不是在這個環境中的話，可能需要修改一些定義，比如DWORD等。其他的API都是windows平台提供的API；
#include <stdio.h>
#include "windows.h"
int main()
{
//獲取進程ID，因為你希望是多個進程運行同時寫一個文件，所以，我們列印出進程ID
DWORD dwProcessID = GetCurrentProcessId();
//初始化我們要寫入文件中的內容，及該內容長度；
char szContent[100] = {0};
sprintf(szContent,"process[%u] write file\r\n",dwProcessID);
DWORD dwContentLen = strlen(szContent);
//創建互斥量，這樣可以進行進程間的互斥，當然用這個也可以做線程間的互斥
HANDLE hMutex = CreateMutex(NULL,FALSE,"MyFileMutex");
if (NULL == hMutex)
{
printf("[%u]Create/Open Mutex error!\r\n",dwProcessID);
return 1;
}
//創建或打開文件
HANDLE hFile = CreateFile("D:\\1.txt",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ,NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_ARCHIVE,
NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
printf("[%u]Creat/Open file error!\r\n",dwProcessID);
return 1;
}
//循環寫入文件
for(int i = 0; i < 1000 ; i++)
{
//等待臨界資源，即鎖定文件
WaitForSingleObject(hMutex,INFINITE);
printf("Process[%u] Get the signal\r\n",dwProcessID);
DWORD len = 0;
//因為是共享寫文件，即多個程序寫一個文件，所以一定要將文件指針偏移到尾部
SetFilePointer(hFile,0,NULL,FILE_END);
//寫入文件
BOOL rnt = WriteFile(hFile,szContent,dwContentLen,&len,NULL);
if (rnt == FALSE)
{
printf("Process[%u] Fail to write file\r\n",dwProcessID);
}
//釋放互斥量，解除鎖定
ReleaseMutex(hMutex);
//加個Sleep便於我們中間觀察結果
Sleep(30);
}
CloseHandle(hMutex);
CloseHandle(hFile);
return 0;
}
應你要求，我把AIP中的宏定義解釋如下：
HANDLE hFile = CreateFile("D:\\1.txt",
GENERIC_READ | GENERIC_WRITE,//表示程序對該文件有讀和寫的許可權
FILE_SHARE_WRITE | FILE_SHARE_READ,//表示可以多個程序共享讀和寫的許可權
NULL,
OPEN_ALWAYS,//表示打開該文件，如果該文件不存在，則創建該文件
FILE_ATTRIBUTE_ARCHIVE,//文件的屬性為存檔
NULL);
WaitForSingleObject(hMutex,INFINITE);
//INFINITE表示永遠等待，直到hMutex有信號為止
SetFilePointer(hFile,0,NULL,FILE_END);
//FILE_END表示從文件尾部開始偏移；實際此舉就是將文件指針偏移到文件尾部；
㈩ C語言如何創建線程（windows）系統中
下面為C語言調用WIN API實現創建線程：
1，導入<windows.h>頭文件
2，聲明實現方法DWORD WINAPI ThreadProc1( LPVOID lpParam ) {}
3，在main()方法中調用 CreateThread(NULL,0 ,ThreadProc1,NULL,0,NULL);
要注意的是主線程不能結束，如果主線程結束，則它的子線程也會被殺死。
#include <windows.h>
#include <stdio.h>
#include<time.h>
DWORD WINAPI ThreadProc1( LPVOID lpParam )
{
int i=0;
time_t timer;
while(1)
{
timer=time(NULL);
printf("The current time is: %s\n",asctime(localtime(&timer)));
sleep(1);
}
}
void main()
{
int i=0;
//讓主線程進入循環，主線程若退出，子線程1，2會被系統「殺死」
//創建線程1
CreateThread(
NULL, // default security attributes
0, // use default stack size
ThreadProc1, // thread function
NULL, // argument to thread function
0, // use default creation flags
NULL); // returns the thread identifier
for(;;)
{
;
}
}