linux線程例子_c語言實例linux線程同步的信號量方式謝謝

A. linux 線程中，線程宿主函數是什麼意思宿體函數又是什麼意思二者有什麼區別最好能舉個例子。

宿主函數是你調用建立線程的函數，而宿體函數是你線程運行起來後執行的函數

B. Linux線程及同步

linux多線程
1.線程概述
線程是一個進程內的基本調度單位，也可以稱為輕量級進程。線程是在共享內存空間中並發的多道執行路徑，它們共享一個進程的資源，如文件描述和信號處理。因此，大大減少了上下文切換的開銷。一個進程可以有多個線程，也就
是有多個線程式控制製表及堆棧寄存器，但卻共享一個用戶地址空間。
2.線程實現
線程創建pthread_create()
所需頭文件#include
<pthread.h>
函數原型int
pthread_create
((pthread_t
*thread,
pthread_attr_t
*attr,
thread：線程標識符
attr：線程屬性設置
start_routine：線程函數的起始地址
arg：傳遞給start_routine的參數
函數返回值
成功：0
出錯：-1
線程退出pthread_exit();
所需頭文件#include
<pthread.h>
函數原型void
pthread_exit(void
*retval)
函數傳入值retval:pthread_exit()調用者線程的返回值，可由其他函數如pthread_join
來檢索獲取
等待線程退出並釋放資源pthread_join()
所需頭文件#include
<pthread.h>
函數原型int
pthread_join
((pthread_t
th,
void
**thread_return))
函數傳入值
th：等待線程的標識符
thread_return：用戶定義的指針，用來存儲被等待線程的返回值（不為NULL時）
函數返回值
成功：0
出錯：-1
代碼舉例
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
/*線程1*/
6.
void
thread1()
7.
{
8.
int
i=0;
9.
10.
while(1)
11.
{
12.
printf(thread1:%d/n,i);
13.
if(i>3)
14.
pthread_exit(0);
15.
i++;
16.
sleep(1);
17.
}
18.
}
19.
20.
/*線程2*/
21.
void
thread2()
22.
{
23.
int
i=0;
24.
25.
while(1)
26.
{
27.
printf(thread2:%d/n,i);
28.
if(i>5)
29.
pthread_exit(0);
30.
i++;
31.
sleep(1);
32.
}
33.
}
34.
35.
int
main()
36.
{
37.
pthread_t
t1,t2;
38.
39.
/*創建線程*/
40.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
41.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
42.
/*等待線程退出*/
43.
pthread_join(t1,NULL);
44.
pthread_join(t2,NULL);
45.
return
0;
46.
}
3同步與互斥
<1>互斥鎖
互斥鎖的操作主要包括以下幾個步驟。
•
互斥鎖初始化：pthread_mutex_init
•
互斥鎖上鎖：pthread_mutex_lock
•
互斥鎖判斷上鎖：pthread_mutex_trylock
•
互斥鎖接鎖：pthread_mutex_unlock
•
消除互斥鎖：pthread_mutex_destroy
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;/*共享變數*/
6.
pthread_mutex_t
mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥鎖*/
7.
8.
void
thread1()
9.
{
10.
int
ret;
11.
while(1)
12.
{
13.
14.
15.
ret=pthread_mutex_trylock(&mutex);/*判斷上鎖*/
16.
17.
if(ret!=EBUSY)
18.
{
19.
pthread_mutex_lock(&mutex);/*上鎖*/
20.
printf(This
is
thread1:%d/n,i);
21.
i++;
22.
pthread_mutex_unlock(&mutex);/*解鎖*/
23.
}
24.
sleep(1);
25.
}
26.
}
27.
28.
void
thread2()
29.
{int
ret;
30.
while(1)
31.
{
32.
33.
ret=pthread_mutex_trylock(&mutex);
34.
if(ret!=EBUSY)
35.
{
36.
pthread_mutex_lock(&mutex);
37.
printf(This
is
thread2:%d/n,i);
38.
i++;
39.
pthread_mutex_unlock(&mutex);
40.
}
41.
sleep(1);
42.
}
43.
}
44.
int
main()
45.
{
46.
pthread_t
t1,t2;
47.
pthread_mutex_init(&mutex,NULL);
48.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
49.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
50.
51.
pthread_join(t1,NULL);
52.
pthread_join(t2,NULL);
53.
54.
pthread_mutex_destroy(&mutex);
55.
return
0;
56.
}
<2>信號量
未進行同步處理的兩個線程
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;
6.
void
thread1()
7.
{
8.
9.
while(1)
10.
{
11.
printf(This
is
thread1:%d/n,i);
12.
i++;
13.
sleep(1);
14.
}
15.
}
16.
17.
18.
void
thread2()
19.
{
20.
21.
while(1)
22.
{
23.
printf(This
is
thread2:%d/n,i);
24.
i++;
25.
sleep(1);
26.
}
27.
}
28.
29.
int
main()
30.
{
31.
pthread_t
t1,t2;
32.
33.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
34.
pthread_create(&t2,NULL,(void
*)thread2,NULL);

C. linux c socket 如何實現一個進程多個線程，每個線程管理多個socket連接

大家仔細看，樓主的題目還是很有難度的呢，一個進程多個線程容易實現，但是要讓這些線程中每個線程都管理多個socket連接，確實比較難~~坐等高手。
不過一般都是一個線程處理一個socket連接，這種例子是：
（取自書上，僅供學習，直接編譯肯定通不過，少書上其他代碼）
==================================================
/* include serv06 */#include "unpthread.h"
intmain(int argc, char **argv)
{
int listenfd, connfd;
void sig_int(int);
void *doit(void *);
pthread_t tid;
socklen_t clilen, addrlen;
struct sockaddr *cliaddr;

if (argc == 2) listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 3)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: serv06 [ <host> ] <port#>");
cliaddr = Malloc(addrlen);

Signal(SIGINT, sig_int);
for ( ; ; ) { clilen = addrlen;
connfd = Accept(listenfd, cliaddr, &clilen);

Pthread_create(&tid, NULL, &doit, (void *) connfd); }
}

void *doit(void *arg)
{
void web_child(int);

Pthread_detach(pthread_self()); web_child((int) arg);
Close((int) arg);
return(NULL);
}
/* end serv06 */

voidsig_int(int signo)
{
void pr_cpu_time(void);

pr_cpu_time(); exit(0);
}
================================================================

D. 關於Linux 線程pthread_join的用法

Linux系統pthread_join用於掛起當前線兆衡程（調用pthread_join的線程），直到thread指定的線程終止運行為止，當前線程才繼續執行。

案例代碼：

/*******************************************
**Name:pthread_join.c
**用於Linux下多線程學習
**案例解釋線程的暫停和結束
**Author:admin
**Date:2015/8/11
**Copyright(c)2015,AllRightsReserved!
**********************************************
#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
void*thread(void*str)
{
inti;
//不調用pthread_join線程族戚做函數
for(i=0;i<10;++i)
{
sleep(2);
printf("Thisinthethread:%d
",i);
}
returnNULL;
}

intmain()
{
pthread_tpth;
inti;
intret=pthread_create(&pth,NULL,thread,(void*)(i));
//調用pthread_join線程函數
pthread_join(pth,NULL);
for(i=0;i<10;++i)
{
sleep(1);
printf("Thisinthemain:%d
",i);
}

return0;
}

通過Linux下shell命令執行上面的案例代碼：

[root@localhostsrc]#gccpthread_join.c-lpthread
[root@localhostsrc]#./a.out
Thisinthemain:0
Thisinthethread:0
Thisinthemain:1
Thisinthemain:2
Thisinthethread:1
Thisinthemain:3
Thisinthemain:4
Thisinthethread:2
Thisinthemain:5
Thisinthemain:6
Thisinthethread:3
Thisinthemain:7
Thisinthemain:8
Thisinthethread:4
Thisinthemain:9

子線程還沒有執行完畢，main函數已經退出，那麼子線程也就退出了，「pthread_join(pth,NULL);」函數起作用。

[root@localhostsrc]#gccpthread_join.c-lpthread
[root@localhostsrc]#./a.out
Thisinthethread:0
Thisinthethread:1
Thisinthethread:2
Thisinthethread:3
Thisinthethread:4
Thisinthethread:5
Thisinthethread:6
Thisinthethread:7
Thisinthethread:8
Thisinthethread:9
Thisinthemain:0
Thisinthemain:1
Thisinthemain:仔晌2
Thisinthemain:3
Thisinthemain:4
Thisinthemain:5
Thisinthemain:6
Thisinthemain:7
Thisinthemain:8
Thisinthemain:9

這說明pthread_join函數的調用者在等待子線程退出後才繼續執行。

E. Linux多線程程序中有哪些變數類型,被映射到哪個地址空間,有幾個運行實例

在 Linux 多線程編程中，通常會使用以下幾種變數類型：

全局變數：定義在所有函數之外的變數，作用域在整個程序中都可見。全局變數被映射到進程的數據段中，所有線程都可以訪問它們。在多線程程序中，需要注意全局變數的並發訪問問題，避免出現競爭條件。
局部變數：定義在函數內部的變數，作用域僅限於函數內部。每個線程都有自己的棧空間，虧祥局部變數被分配在棧上，每個線程都有自己獨立的棧空間，互不幹擾。
線程私有變數：每個線程都有自己的私有變數。可以使用 pthread_key_create() 函數創建一個線程私有變數，使用 pthread_getspecific() 和 pthread_setspecific() 函數來設置和獲取線程私有變數的值。線程私有變數被映射到進程的線程局部存儲段（Thread Local Storage, TLS）中，每個線程都有自己獨立的 TLS，互不幹擾。
共享變數：被多個線程共享的變數。在多線程程序中，需要使用鎖（如互斥鎖、讀寫鎖）等機制來保護共享變數，避免出現競爭條件橡鉛。共享變數被映射到進程的數據段中，所有線程都可以訪問它們。

需要注意的是，在多線程程序中，這些變數類型在地址空間中的位置和數量都是相對復雜的，因為每個線程都有自己獨梁空好立的棧空間和 TLS，這些變數的地址在不同的線程中可能是不同的。因此，在多線程程序中，需要使用適當的同步機制來保護這些變數，以確保程序的正確性和可靠性。

F. c語言實例，linux線程同步的信號量方式謝謝

這么高的懸賞，實例放後面。信號量(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;
}

導航:首頁 > 操作系統 > linux線程例子

linux線程例子

與linux線程例子相關的資料