線程linux

❶ linux線程如何運行

pthread_create執行後，如果執行成功會生成一個子線程 也就是現在有兩個線程同時運行
父線程還會繼續執行後面的代碼 直到結束
子線程則開始執行thread函數體里的代碼了 別的不執行
pthread_join會按照父線程執行順序 到它了就會執行 該函數的作用是阻塞等待一個線程執行完畢
在你的代碼里 不一定在子線程執行3次後才啟動 也可能子線程沒有執行呢 父線程就執行到pthread_join了 然後阻塞等待子線程
如果你想讓pthread_join在子線程3次執行後才啟動 可以讓父線程sleep下 不過子線程執行完了 你再執行pthread_join也就沒有什麼意義了
不懂再問

❷ linux中的線程有哪幾種狀態

就緒：線程分配了CPU以外的全部資源，等待獲得CPU調度
執行：線程獲得CPU，正在執行
阻塞：線程由於發生I/O或者其他的操作導致無法繼續執行，就放棄處理機，轉入線程就緒隊列
掛起：由於終端請求，操作系統的要求等原因，導致掛起。

❸ Linux中進程和線程的對比與區別

線程和進程是另一對有意義的概念，主要區別和聯系如下：

• 進程是操作系統進行資源分配的基本單位，擁有完整的進程空間。進行系統資源分配的時候，除了CPU資源之外，不會給線程分配獨立的資源，線程所需要的資源需要共享。

• 線程是進程的一部分，如果沒有進行顯示的線程分配，可以認為進程是單線程的；如果進程中建立了線程，則可認為系統是多線程的。

• 多線程和多進程是兩種不同的概念。多線程與多進程有不同的資源共享方式。

• 進程有進程式控制制塊PCB，系統通過PCB對進程進行調度。進程有線程式控制制塊TCP，但TCB所表示的狀態比PCB要少的多。

❹ Linux到底有沒有線程

線程只是一個概念，Linux視線程和進程是一樣的，所以它只需要一個「進程」的概念，Windows視線程為進程生成的更小粒度單位。
所以其實大家只是看待問題角度不同，不代表Linux「沒有」線程

❺ java的多線程與linux的多線程的關系

java自己實現了線程庫，也就是說java的線程並不和操作系統的線程對應，jvm在操作系統上面是一個進程，當這個進程被操作系統調度到後，jvm內部實現的線程庫再調度java線程，為什麼是這樣呢？考慮到以前的操作系統內核，比如linux，在以前都不直接支持線程，用戶線程和內核線程是多對一的關系，solaris一度也是這樣，所以java當然心有餘而力不足了，你操作系統都不能完美支持線程，你讓我實現不是難為我嗎？在那個年代，java多線程的調度完全是自主的，操作系統根本不知道java是多線程的，調度策略完全自己實現，單cpu下肯定是分時的，多cpu下就看jvm會不會建立多cpu上的多jvm實例了。
到了後來，操作系統內核紛紛都支持了多線程（windows開始就支持），那麼java也要考慮推卸一些責任了，這樣java線程就和操作系統線程一一對應或多多對應了，這個時候，如果是一一對應，那麼線程的調度完全交給了操作系統內核，當然jvm還保留一些策略足以影響到其內部的線程調度，舉個例子，在linux下，只要一個Thread.run就會調用一個fork產生一個線程。
問：java獲得cup使用權採用的搶占機制，使用cup的時候是分時機制，這句話對不對？
答：部分對，早期實現，基本可以實現搶占式，但是現代實現，如果系統不支持搶占，那麼jvm也無所謂搶佔了。
問：多線程使用cup和使用的操作系統有關還是java機制有關（xp是什麼機制）
答：早期是java機制實現，現在大部分是操作系統實現的，java機制僅僅保留了相關策略從而影響調度；xp是基於優先順序的搶占式調度，其性能很大程度依賴於動態優先順序提升

❻ Linux線程的幾種結束方式

Linux線程的幾種結束方式
Linux創建線程使用
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void *), void *arg)
1
2
Linux線程的幾種結束方式：
調用pthread_exit(exit_code)，exit_code為線程退出的狀態代碼。同一進程下的其他線程可以通過pthread_join(exit_code)來使用。
函數start_routine使用return返回，與調用pthread_exit()作用相同。
線程被取消pthread_cancel()。
同一進程中的其他線程調用了exit(),，或者主線程從main函數返回。

❼ linux 最多支持多少個線程

默認情況下：
主線程＋輔助線程 ＋<253個自己的線程<＝255
含主線程和一個輔助線程，最多255個，即一個用戶只能生成253個線程。
Linux最大線程數限制及當前線程數查詢：
1、總結系統限制有：
/proc/sys/kernel/pid_max #查系統支持的最大線程數，一般會很大，相當於理論值
/proc/sys/kernel/thread-max
max_user_process（ulimit -u） #系統限制某用戶下最多可以運行多少進程或線程
/proc/sys/vm/max_map_count
硬體內存大小
2、Java虛擬機本身限制：
-Xms #intial java heap size
-Xmx #maximum java heap size
-Xss #the stack size for each thread
3、查詢當前某程序的線程或進程數
pstree -p `ps -e | grep java | awk '{print $1}'` | wc -l 或 pstree -p 3660 | wc -l
4、查詢當前整個系統已用的線程或進程數
pstree -p | wc -l
1、 cat /proc/${pid}/status
2、pstree -p ${pid}
3、top -p ${pid} 再按H 或者直接輸入 top -bH -d 3 -p ${pid}
top -H
手冊中說：-H : Threads toggle
加上這個選項啟動top，top一行顯示一個線程。否則，它一行顯示一個進程。
4、ps xH
手冊中說：H Show threads as if they were processes
這樣可以查看所有存在的線程。
5、ps -mp <PID>
手冊中說：m Show threads after processes
這樣可以查看一個進程起的線程數。

❽ linux終端中如何查看用了多少個線程

1、top -H
top命令是linux下常用的性能分析工具，也是一個強大的系統檢測工具，能夠實時顯示系統中各個進程的資源佔用狀況，類似於Windows的任務管理器
-H : Threads toggle是否顯示線程，為on時將顯示所有線程
2、ps xH
ps查看當前用戶的活動進程
-H： Show threads as if they were processes
查看所有存在的線程。
3、ps -mp <PID>
-m： Show threads after processes
查看某個進程的線程

❾ 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);