線程函數c語言

㈠ c語言多線程實現

多線程隨機選號程序
以下程序運行後看起來比較有意思,像一個隨機選號程序,但不是完全按照問題所說的寫的
可供參考,要改很容易
//多線程隨機選號程序示例
#include
<stdio.h>
#include
<Windows.h>
#include
<ctime>
#include
<cstdlib>
#include
<process.h>
bool
g_run
=
true;
//是否運行
void
userInput(void*)
//監視輸入的線程函數
{
while
(true)
{
if
(getchar()=='\n')
//是否輸入回車
{
g_run
=
!g_run;
//回車運行
回車暫停
}
Sleep(10);
//延遲
}
}
int
main()
{
srand(time(0));
//隨機數種子
_beginthread(userInput,0,NULL);
//開線程
while
(true)
{
if
(g_run)
{
system("cls");
//清屏
int
t
=
rand()
%
1000+
1;//1-1000的隨機數
printf("\n
%d",t);
//輸出
}
Sleep(50);
//延遲50毫秒
}
return
0;
}

㈡ C語言中 怎麼實現雙線程 或者 父子線程啊

運行一個程序，這個運行實體就是一個「進程」。

例如，用滑鼠雙擊IE瀏覽器的圖標，你運行了一個IE「進程」。第一個窗未關，你又用滑鼠雙擊IE瀏覽器的圖標，又出來一個瀏覽器的窗。這時，你運行了同一個程序的兩個進程。

對於自己寫的程序也如此。運行它，這個運行實體就是一個「進程」。同時運行兩個，就是兩個進程。計算機分別對兩個進程分配資源，直到進程結束，收回資源。

線程是進程里真真跑的線路，真真執行的運算，每個進程有一個主線程。進程里可以開第二第三條新的執行線路，gcc 用 pthread_create()，VC++ 用 CreateThread(), 這就叫雙線程和多線程。進程是線程的容器，同一進程的線程共享它們進程的資源。線程里建的線程就是父子線程。

兩個或多個進程協同工作時，需要互相交換信息，有些情況下進程間交換的少量信息，有些情況下進程間交換大批信息。這就要通訊。通訊方式不止一種。管道就是一種。VC++ 用 CreatePipe() 函數建立。

管道的實質是一個共享文件，可藉助於文件系統的機制實現，創建、打開、關閉和讀寫.

一個進程正在使用某個管道寫入或讀出數據時，另一個進程就必須等待. 發送者和接收者雙方必須知道對方是否存在，如果對方已經不存在，就沒有必要再發送信息.,發送信息和接收信息之間要協調，當寫進程把一定數量的數據寫入管道，就去睡眠等待，直到讀進程取走數據後，把它喚醒。

VC++ 線程例子：
#include <windows.h>
#include <iostream.h>

DWORD WINAPI fun1(LPVOID lp);
DWORD WINAPI fun2(LPVOID lp);
int piao=500;

int main()
{
HANDLE pthread1,pthread2;
pthread1=CreateThread(0,0,fun1,0,0,0);
pthread2=CreateThread(0,0,fun2,0,0,0);
CloseHandle(pthread1);
CloseHandle(pthread2);
Sleep(3000);
return 0;

}

DWORD WINAPI fun1(LPVOID lp)
{
while(1)
{

if(piao>0)
cout<< "thread-1-"<< piao--<<endl;
else
break;
}
return 0;
}

DWORD WINAPI fun2(LPVOID lp)
{
while(1)
{
if(piao>0)
cout<<"thread-2-"<<piao--<<endl;
else
break;
}
return 0;
}

===================================
建管道函數原形：
BOOL CreatePipe(
PHANDLE hReadPipe, // read handle
PHANDLE hWritePipe, // write handle
LPSECURITY_ATTRIBUTES lpPipeAttributes, // security attributes
DWORD nSize // pipe size
);

㈢ C語言如何終止線程

有三種方式可以終止線程，具體調用函數依賴於使用的線程系統。
1 在線程入口函數中，調用return。 即退出線程入口函數，可以實現終止當前線程效果；
2 在線程執行的任意函數，調用當前線程退出函數，可以退出當前線程；
3 在任意位置，調用線程終止函數，並傳入要終止線程的標識符，即pid，可以實現終止對應線程效果。

㈣ C語言如何實現多線程同時運行

1、點擊菜單欄的「Project」選項卡，下拉列表的最後一項「Project options...」是對當前工程的的屬性進行設置的。

㈤ C語言 殺死線程 Api函數

GetExitCodeThread函數可以得到線程終結時的返回值，因為線程終結了，所以系統中不再有這個線程，hThreadRcvData本身已經無效，所以調用TerminateThread函數會失敗。

㈥ c語言 怎麼定義一個多線程函數呢，急等

main()
{
if(！fork())
{
//代碼
//...新線程,與原線程共享數據空間
}
else
{
//代碼
//..原線程,與新線程共享數據空間
}
}

這樣就可以了
但是vc不可以用的

vc有自己的c++多線程函數

㈦ C語言怎麼寫線程代碼

通常使用CreateThread函數來創建新的線程.(Unix下使用pthread_create函數)
首先指出,線程與線程之間,是並列關系,不會存在"父子線程"的概念.
在Windows平台下,CreateThread函數包含在 Windows.h 文件內,包含此文件即可正常使用.
以下為CreateThread函數的聲明:
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,//指向安全性屬性描述結構體的
//指針,通常可以忽略的.
SIZE_T dwStackSize,//指定新線程初始的棧大小,若不關心,可以用0填充,來要求使用
//默認值

LPTHREAD_START_ROUTINE lpStartAddress,//用來充當線程的函數的指針.
LPVOID lpParameter,//要傳遞給函數的參數,這個值本身就是那個參數,而不是參數的地址
DWORD dwCreationFlags,//創建的方式,0表示正常,創建後立即開始運行
LPDWORD lpThreadId//用來接受函數反饋的線程ID的指針.
);

用來充當新的線程的函數格式:
DWORD WINAPI ThreadProc(LPVOID);

CreateThread函數若成功了,返回新線程的句柄,若失敗了,則返回NULL.

若用CREATE_SUSPENDED填充dwCreation Flags則創建的線程先掛起來,並不直接開始運行,要用ResumeThread函數恢復線程,才能繼續運行.

㈧ C語言多線程式控制制函數

this.Invoke((EventHandler)(delegate
{
READ1();
}));
this.Invoke((EventHandler)(delegate
{
READ2();
}));

㈨ C語言線程函數參數問題

·線程創建
函數原型：int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void),void *restrict arg);
返回值：若是成功建立線程返回0，否則返回錯誤的編號。

形式參數：pthread_t *restrict tidp要創建的線程的線程id指針；
const pthread_attr_t *restrict attr創建線程時的線程屬性；
void* (start_rtn)(void)返回值是void類型的指針函數；
void *restrict arg start_rtn的形參。 =====這個地方就可以傳參數，
注意，這個地方是個指針，要想傳多個參數，可以定義一個結構體，把要傳的參數包起來，傳結構體的地址就ok

㈩ 請問用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]);

}
}

看函數就行