linux開啟線程

⑴ linux 線程問題

主要理解在fork函數。
你可以參考
http://hi..com/huifeng00/blog/item/c7e9a4c6c5e6eac739db49b6.html
這會產生分支，
fork會產生一個子進程。
根據fork的返回值的不同運行不同的代碼。
在子進程返回值是0，而父進程就是調用這個函數的進程中返回的則是進程的ID也就是>0。
所以在子進程中執行
pthread_attr_init(&attr);
pthread_create(&tid,&attr,runner,NULL);
pthread_join(tid,NULL);
printf("CHILD:value=%d",value);
這個子進程會啟動一個線程
void*runner(void*param){
value=5;
pthread_exit(0);
}
讓value=5;
所以輸出
CHILD:value=5；
而父進程則執行
wait(NULL);
printf("PARENT:value=%d",value);
由於wait()所以它會暫停父進程，等待子進程結束。
子進程結束後，然後父進程運行輸出
PARENT:value=0
至於為什麼是0，因為子進程和父進程的數據是在內存中各有一份的。
子進程只是改變了它那份。父進程中還是0.

⑵ linux線程可以創建線程嗎

創建線程一般都是在主線程裡面創建，因為在主線程裡面能夠對線程進行管理控制，而且還有很重要的一點，就是Linux編程中使用線程的好處是可以共享變數，這在主線程的main函數裡面更加方便，所以沒有在線程中再創建線程的用法。既然想在線程中再創建線程，為何不用fork復制進程呢，Linux的進程開銷是非常小的。

⑶ Linux多線程實現線程間不停的切換

你這個問題很有意思。第一次執行的時候，可以看出，能執行0~6共7次；第二次的時候，從6開始，到5，只有2次了，並且以後都是只有2次。
基於你的描述，我想可以用互斥信號量來做。
1、初始化2個信號量pmutex1（有資源）， pmutex2（無資源），初始化gnum=0
2、啟動兩個線程
2.1 線程1
lock_the_mutex_signal(pmutex1); // 上鎖自身線程，首次可執行
while (gnum < 5) {
do_sth(); // 做你的業務邏輯

gnum++; // 增加執行次數

} // end while()
unlock_the_mutex_signal(pmutex2); // 解鎖另一線程
2.2 線程2

lock_the_mutex_signal(pmutex2); // 上鎖自己，首次執行將阻塞，並交出CPU
while (gnum > 5) {
do_sth(); // ...

gnum--; // ...

} // end while()
unlock_the_mutex_signal(pmutex1); // release the lock
PS：如果你不是非常嚴格地（從系統級杜絕不該被執行的線程被調用）要求線程切換的話，這個邏輯應該可以工作。自己沒有試，希望你明白我的思想，如有錯誤，自己再修改一下。

⑷ linux 一個進程 最多開多少線程

32為linux系統最大內存地址4G，0-3GB的給用戶進程(User Space)使用，3-4GB給內核使用
stack size (kbytes, -s) 10240表示線程堆棧大小
3G/10M=最大線程數，但實際會比這個數小一點，因為程序本身占內存，還有些管理線程
可以使用ulimit -s來設置stack size，設置的小一點開辟的線程就多。

同時/usr/include/bits/local_lim.h中的PTHREAD_THREADS_MAX限制了進程的最大線程數
/proc/sys/kernel/threads-max中限制了系統的最大線程數

你自己寫個簡單的代碼就能測試出自己系統最大可以開多少線程

#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>

void *foo(void *param)
{
}

int main()
{
int i = 0;
pthread_t thread;
while(1)
{
if(pthread_create(&thread,NULL,foo,NULL) != 0)
break;
i++;
}
printf("i=%d\n",i);
return 0;
}

⑸ Linux下多線程的如何執行

主線程結束，則進程結束，屬於該進程的所有線程都會結束，可以在主線程中join，也可以在主線程中加死循環。

⑹ C++在linux下怎麼多線程

#ifndefTHREAD_H_
#defineTHREAD_H_
#include<unistd.h>
#include<pthread.h>
classRunnable
{
public:
//運行實體
virtualvoidrun()=0;
};
//線程類
classThread:publicRunnable
{
private:
//線程初始化號
staticintthread_init_number;
//當前線程初始化序號
intcurrent_thread_init_number;
//線程體
Runnable*target;
//當前線程的線程ID
pthread_ttid;
//線程的狀態
intthread_status;
//線程屬性
pthread_attr_tattr;
//線程優先順序
sched_paramparam;
//獲取執行方法的指針
staticvoid*run0(void*pVoid);
//內部執行方法
void*run1();
//獲取線程序號
staticintget_next_thread_num();
public:
//線程的狀態－新建
staticconstintTHREAD_STATUS_NEW=0;
//線程的狀態－正在運行
staticconstintTHREAD_STATUS_RUNNING=1;
//線程的狀態－運行結束
staticconstintTHREAD_STATUS_EXIT=-1;
//構造函數
Thread();
//構造函數
Thread(Runnable*target);
//析構
~Thread();
//線程的運行體
voidrun();
//開始執行線程
boolstart();
//獲取線程狀態
intget_state();
//等待線程直至退出
voidjoin();
//等待線程退出或者超時
voidjoin(unsignedlongmillis_time);
//比較兩個線程時候相同，通過current_thread_init_number判斷
booloperator==(constThread*other_pthread);
//獲取this線程ID
pthread_tget_thread_id();
//獲取當前線程ID
staticpthread_tget_current_thread_id();
//當前線程是否和某個線程相等，通過tid判斷
staticboolis_equals(Thread*iTarget);
//設置線程的類型:綁定/非綁定
voidset_thread_scope(boolisSystem);
//獲取線程的類型:綁定/非綁定
boolget_thread_scope();
//設置線程的優先順序，1－99，其中99為實時，意外的為普通
voidset_thread_priority(intpriority);
//獲取線程的優先順序
intget_thread_priority();
};
intThread::thread_init_number=1;
inlineintThread::get_next_thread_num()
{
returnthread_init_number++;
}
void*Thread::run0(void*pVoid)
{
Thread*p=(Thread*)pVoid;
p->run1();
returnp;
}
void*Thread::run1()
{
thread_status=THREAD_STATUS_RUNNING;
tid=pthread_self();
run();
thread_status=THREAD_STATUS_EXIT;
tid=0;
pthread_exit(NULL);
}
voidThread::run()
{
if(target!=NULL)
{
(*target).run();
}
}
Thread::Thread()
{
tid=0;
thread_status=THREAD_STATUS_NEW;
current_thread_init_number=get_next_thread_num();
pthread_attr_init(&attr);
}
Thread::Thread(Runnable*iTarget)
{
target=iTarget;
tid=0;
thread_status=THREAD_STATUS_NEW;
current_thread_init_number=get_next_thread_num();
pthread_attr_init(&attr);
}
Thread::~Thread()
{
pthread_attr_destroy(&attr);
}
boolThread::start()
{
returnpthread_create(&tid,&attr,run0,this);
}
inlinepthread_tThread::get_current_thread_id()
{
returnpthread_self();
}
inlinepthread_tThread::get_thread_id()
{
returntid;
}
inlineintThread::get_state()
{
returnthread_status;
}
voidThread::join()
{
if(tid>0)
{
pthread_join(tid,NULL);
}
}
voidThread::join(unsignedlongmillis_time)
{
if(tid==0)
{
return;
}
if(millis_time==0)
{
join();
}
else
{
unsignedlongk=0;
while(thread_status!=THREAD_STATUS_EXIT&&k<=millis_time)
{
usleep(100);
k++;
}
}
}
boolThread::operator==(constThread*other_pthread)
{
if(other_pthread==NULL)
{
returnfalse;
}if(current_thread_init_number==(*other_pthread).current_thread_init_number)
{
returntrue;
}
returnfalse;
}
boolThread::is_equals(Thread*iTarget)
{
if(iTarget==NULL)
{
returnfalse;
}
returnpthread_self()==iTarget->tid;
}
voidThread::set_thread_scope(boolisSystem)
{
if(isSystem)
{
pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM);
}
else
{
pthread_attr_setscope(&attr,PTHREAD_SCOPE_PROCESS);
}
}
voidThread::set_thread_priority(intpriority)
{
pthread_attr_getschedparam(&attr,&param);
param.__sched_priority=priority;
pthread_attr_setschedparam(&attr,&param);
}
intThread::get_thread_priority(){
pthread_attr_getschedparam(&attr,&param);
returnparam.__sched_priority;
}
#endif/*THREAD_H_*/

⑺ linux內核如何打開超線程

通常來說，超線程功能在bios里是默認開啟的，
如果你cpu支持超線程，則會自動模擬為物理核心x2；
如果超線程沒有開啟，可以在開機的時候，進入bios里，找hyper-threading項，改為enabled就是開啟超線程

⑻ linux 多線程cpu運行時間

這個月時間比較長的，因為這個度現成的CPU使用起來非常的好

⑼ linux如何進行線程管理

方法一：PS
在ps命令中，「-T」選項可以開啟線程查看。下面的命令列出了由進程號為<pid>的進程創建的所有線程。
1.$ ps -T -p <pid>

「SID」欄表示線程ID，而「CMD」欄則顯示了線程名稱。

方法二： Top
top命令可以實時顯示各個線程情況。要在top輸出中開啟線程查看，請調用top命令的「-H」選項，該選項會列出所有Linux線程。在top運行時，你也可以通過按「H」鍵將線程查看模式切換為開或關。
1.$ top -H

要讓top輸出某個特定進程<pid>並檢查該進程內運行的線程狀況：
$ top -H -p <pid>