c語言的線程同步
這么高的懸賞，實例放後面。信號量(sem),如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。
信號量初始化。
intsem_init(sem_t*sem,intpshared,unsignedintvalue);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
intsem_wait(sem_t*sem);
釋放信號量。信號量值加1。並通知其他等待線程。
intsem_post(sem_t*sem);
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
intsem_destroy(sem_t*sem);
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<errno.h>
#definereturn_if_fail(p)if((p)==0){printf("[%s]:funcerror!/n",__func__);return;}
typedefstruct_PrivInfo
{
sem_ts1;
sem_ts2;
time_tend_time;
}PrivInfo;
staticvoidinfo_init(PrivInfo*thiz);
staticvoidinfo_destroy(PrivInfo*thiz);
staticvoid*pthread_func_1(PrivInfo*thiz);
staticvoid*pthread_func_2(PrivInfo*thiz);
intmain(intargc,char**argv)
{
pthread_tpt_1=0;
pthread_tpt_2=0;
intret=0;
PrivInfo*thiz=NULL;
thiz=(PrivInfo*)malloc(sizeof(PrivInfo));
if(thiz==NULL)
{
printf("[%s]:Failedtomallocpriv./n");
return-1;
}
info_init(thiz);
ret=pthread_create(&pt_1,NULL,(void*)pthread_func_1,thiz);
if(ret!=0)
{
perror("pthread_1_create:");
}
ret=pthread_create(&pt_2,NULL,(void*)pthread_func_2,thiz);
if(ret!=0)
{
perror("pthread_2_create:");
}
pthread_join(pt_1,NULL);
pthread_join(pt_2,NULL);
info_destroy(thiz);
return0;
}
staticvoidinfo_init(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
thiz->end_time=time(NULL)+10;
sem_init(&thiz->s1,0,1);
sem_init(&thiz->s2,0,0);
return;
}
staticvoidinfo_destroy(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
sem_destroy(&thiz->s1);
sem_destroy(&thiz->s2);
free(thiz);
thiz=NULL;
return;
}
staticvoid*pthread_func_1(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s2);
printf("pthread1:pthread1getthelock./n");
sem_post(&thiz->s1);
printf("pthread1:pthread1unlock/n");
sleep(1);
}
return;
}
staticvoid*pthread_func_2(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s1);
printf("pthread2:pthread2gettheunlock./n");
sem_post(&thiz->s2);
printf("pthread2:pthread2unlock./n");
sleep(1);
}
return;
}
2. 如何用C語言實現多線程下生產者消費者互斥同步問題
整個程序以偽代碼形式給出，當做一個提示吧，這樣你就應該有思路了
生產者在存儲區滿時不能再生產，進入等待，消費者同理
完成同步互斥效果
/*----以下為代碼部分-----*/
//定義全局變數
int empty = 1;//信號量表示存儲單元空，可以生產產品
int full = 0;//信號量表示存儲單元空，不可以消費產品
//P操作
void P(int &mutex)
{
*mutex--;
if(*mutex<0)
{
//當前進程掛起的程序實現
}
}
//V操作
void V(int &mutex)
{
*mutex++;
if(*mutex <=0)
{
//喚醒等待中的進程程序實現
}
}
//生產者程序
void procer()
{
P(& empty);//若此時存儲區空，則可以生產，否則程序掛起等待
//生產一個產品操作
V(&full);//通知消費者進程，可以取產品
}
//消費者程序
void consumer(){
P(&full);//若此時存儲區不空，則可以取產品，否則消費者程序掛起等待
//取走一個產品操作
V(& empty);//通知生產者進程可以生產
}
//主函數
void main()
{
//分別調用生產者，消費者程序，順序不限，因為已經完成信號量的同步，若發生同步問題就會等待
procer()；
consumer()；
consumer()；
procer()；
………………
}
3. 如何用c語言編寫同步與互斥線程 csdn
pthread_create(pthread_t *thread, pthread_attr_t * attr, void *(*start_routine)(void *),void *arg);創建線程（默認為同步線程）
線程的互斥函數有：互斥函數的初始化pthread_mutex_init（），互斥函數的鎖定函數pthread_mutex_lock（），互斥函數的預鎖定函數pthread_mutex_trylock（），互斥函數的解鎖函數pthread_mutex_unlock（），互斥函數的銷毀函數pthread_mutex_destroy（）
4. 用C語言開多線程，想讓多個相同的子線程同時運行，怎麼實現
工作線程是處理後台工作的，創建一個線程非常簡單，只需要兩步：實線線程函數和開始線程.不需要由CWinThread派生類,你可以不加修改地使用CWinThread。
AfxBeginThread有兩種形式，一種是用來創建用戶界面線程的，另一種就是用來創建工作線程的.為了開始執行線程，只需要向AfxBeginThread提供下面的參數就可以了.
1.線程函數的地址
2.傳送到線程函數的參數
3.（可選的）線程的優先順序，可參閱::SetThreadPriority
4.（可選的）線程開始時候的狀態,可設置為CREATE_SUSPENEDE
5.（可選的）線程的安全屬性,請參閱SECURITY_ATTRIBUTES
實例代碼
UINT ThreadProc(LPVOID pParam)
{
return 0;//線程成功完成
}
CWinThread* AfxBeginThreadProc,//線程函數地址
LPVOID pParam,//線程參數
int nPriority=THREAD+PRIORITY_NOMAL,//線程優先順序
int nStackSize=0,//線程堆棧大小，默認為1M
DWORD dwCreateFlags=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL
);
5. 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
);
6. C語言如何實現多線程同時運行
1、點擊菜單欄的「Project」選項卡，下拉列表的最後一項「Project options...」是對當前工程的的屬性進行設置的。
7. C語言如何在線程間實現同步和互斥
線程之間的同步和互斥解決的問題是線程對共同資源進行訪問。Posix有兩種方式：
信號量和互斥鎖；信號量適用同時可用的資源為多個的情況；互斥鎖適用於線程可用的資源只有一個的情況
1、互斥鎖：互斥鎖是用加鎖的方式來控制對公共資源的原子操作(一旦開始進行就不會被打斷的操作)
互斥鎖只有上鎖和解鎖兩種狀態。互斥鎖可以看作是特殊意義的全局變數，因為在同一時刻只有一個線程能夠對互斥鎖進行操作；只有上鎖的進程才可以對公共資源進行訪問，其他進程只能等到該進程解鎖才可以對公共資源進行操作。
互斥鎖操作函數：
pthread_mutex_init();//初始化
pthread_mutex_lock();//上鎖 參數：pthread_mutex_t *mutex
pthread_mutex_trylock();//判斷上鎖 參數：pthread_mutex_t *mutex
pthread_mutex_unlock();//解鎖 參數：pthread_mutex_t *mutex
pthread_mutex_release();//消除互斥鎖 參數：pthread_mutex_t *mutex
互斥鎖分為快速互斥鎖、遞歸互斥鎖、檢錯互斥鎖；在 init 的時候確定
int pthread_mutex_t(pthread_mutex_t *mutex, const pthread_mutex_t mutexattr);
第一個參數：進行操作的鎖
mutexattr：鎖的類型，默認快速互斥鎖（阻塞）123456789
2、信號量：信號量本質上是一個計數器，在操作系統做用於PV原子操作；
P操作使計數器－1；V操作使計數器+1.
在互斥操作中可以是使用一個信號量；在同步操作中需要使用多個信號量，並設置不同的初始值安排它們順序執行
sem_init(); // 初始化操作
sem_wait(); // P操作，計數器減一；阻塞 參數：sem_t *sem
sem_trywait(); // P操作，計數器減一；非阻塞 參數：sem_t *sem
sem_post(); // V操作，計數器加一 參數：sem_t *sem
sem_destroy(); // 銷毀信號量 參數：sem_t *sem
sem_init(sem_t *sem, int pshared, int value);
pshared用於指定多少個進程共享；value初始值
8. 用C語言如何實現多線程同時運行的情況下，各個線程輸出不同的隨機數
1、使用pthread庫執行多線程，這個是Linux下的線程庫 Windows下應該有自己的API，不過這種東西一般還是以Linux為標准。pthread_create()創建一個線程，傳入fun()的函數指針就行了。然後這個Beep()的需求要進行線程間通信，可以用共享內存的方法，設一個bool變數flag共享，然後beep的時候設為false，beep完設成true。fun()裡面每次看一下這個flag，是false的話就不做動作等下一秒，基本可以滿足需求。
2、常式：
#include<pthread.h>
#include<stdio.h>
#include<sys/time.h>
#include<string.h>
#defineMAX10
pthread_tthread[2];
pthread_mutex_tmut;
intnumber=0,i;
void*thread1()
{
printf("thread1:I'mthread1 ");
for(i=0;i<MAX;i++)
{
printf("thread1:number=%d ",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(2);
}
printf("thread1:主函數在等我完成任務嗎？ ");
pthread_exit(NULL);
}
void*thread2()
{
printf("thread2:I'mthread2 ");
for(i=0;i<MAX;i++)
{
printf("thread2:number=%d ",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(3);
}
printf("thread2:主函數在等我完成任務嗎？ ");
pthread_exit(NULL);
}
voidthread_create(void)
{
inttemp;
memset(&thread,0,sizeof(thread));//comment1
/*創建線程*/
if((temp=pthread_create(&thread[0],NULL,thread1,NULL))!=0)//comment2
printf("線程1創建失敗! ");
else
printf("線程1被創建 ");
if((temp=pthread_create(&thread[1],NULL,thread2,NULL))!=0)//comment3
printf("線程2創建失敗");
else
printf("線程2被創建 ");
}
voidthread_wait(void)
{
/*等待線程結束*/
if(thread[0]!=0){//comment4
pthread_join(thread[0],NULL);
printf("線程1已經結束 ");
}
if(thread[1]!=0){//comment5
pthread_join(thread[1],NULL);
printf("線程2已經結束 ");
}
}
intmain()
{
/*用默認屬性初始化互斥鎖*/
pthread_mutex_init(&mut,NULL);
printf("我是主函數哦，我正在創建線程，呵呵 ");
thread_create();
printf("我是主函數哦，我正在等待線程完成任務阿，呵呵 ");
thread_wait();
return0;
}
9. c語言多個線程循環次數極大時如何減小時間差實現同步運行
使用線程同步技術，可以協調多線程的同步問題
10. C語言多線程線程同步可以干什麼
線程同步
比如你要操作大量數據，再有界面的情況下會卡住，實際上是在運行的，但是你會以為它卡死了，線程同步就是解決這類問題，讓操作量大的工作交給一個線程，界面的顯示交給另一個線程