linuxc線程

『壹』 linux下c語言編程線程有什麼好處呢

進程和線程都是由操作系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的並發性。進程和線程的區別在於：

線程的劃分尺度小於進程，使得多線程程序的並發性搞。

另外，進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。

線程在執行過程中與進程還是有區別的。每個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。

從邏輯角度來看，多線程的意義在於一個應用程序中，有多個執行部分可以同時執行。但操作系統並沒有將多個線程看做多個獨立的應用，來實現進程的調度和管理以及資源分配。這就是進程和線程的重要區別。

進程（Process）是最初定義在Unix等多用戶、多任務操作系統環境下用於表示應用程序在內存環境中基本執行單元的概念。以Unix操作系統為例，進程是Unix操作系統環境中的基本成分、是系統資源分配的基本單位。Unix操作系統中完成的幾乎所有用戶管理和資源分配等工作都是通過操作系統對應用程序進程的控制來實現的。

一般你運行一個應用程序,就生成了一個進程, 這個進程擁有自己的內存空間,

這個進程還可以內部生成多個線程, 這些線程之間共用一個進程的內存空存空間,所以線程之間共享內存是很容易做到的,多線程協作比多進程協作快一些,而且安全.

在windows跟unix上面,進程,線程的實現方法都是不一樣的.

『貳』 linux c 多線程 響應時間

BAC的順序,只是啟動下一個線程前,需要等待另一個線程的結果返回,你可以配合介面,來回調,
例如:
class Main implement BListener{
public void startTask(){
啟動B線程,並傳入listener實例,來回調用;
}
//override
public void BTaskComplete(){
B線程成功執行;

啟動A線程;
}

}

class B extends Thread{
可以構造時獲取Listener實例;
public void run(){

執行完畢出結果,Listener.BTaskComplete();

}

}

『叄』 Linux c如何創建線程池

linux c 並沒有自帶的線程池，純C的線程池很少

1：使用glib的線程池，gthreadpool，這個是linux C 下面的一個線程池實現，可以用於生產環境。
2：自己設計線程池，但是設計一個工業強度的線程池是一件非常復雜的事情，尤其用C來實現。一般思路就是建立一個線程池管理函數，一個線程函數並創建一組線程，一個全局的線程狀態數組，線程管理函數通過全局線程狀態數組來分派任務，線程函數更改自己的線程狀態來上報自己的運行情況，實現起來還是相當復雜的。
建議不要重復造輪子，直接使用現有的線程池實現，glib是很好的選擇。

『肆』 linux c 線程間同步（通信）的幾種方法

線程間通信就是通過全局變數啊，線程之間沒有「通信」的說法吧，不管有幾個線程，它們都是在同一個進程地址空間內，都共享同樣的內存空間，所以「通信」的說法才多見於進程之間，因為不同的進程才是不同的內存地址空間。進程內的變數每個線程都是可以訪問的，是共享的，但是線程之間沒有固定的執行順序，為避免時序上的不同步問題，所以線程之間才會需要同步機制。線程之間的重點就是同步機制。

『伍』 linux C 在線程外部獲取該線程的ID的方法！！！

std::this_thread::get_id();

or

GetCurrentThreadId();

『陸』 Linux C下如何創建一個線程

pthread_create(&id,NULL,move,stack);//若stack為字元數組而非字元指針時，傳入時不需要強轉

調用時：

void* move(void* str)
{
char *p = (char*)str;//由void*強轉為char*
......
}

『柒』 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系統下，c語言pthread多線程編程傳參問題

3個線程使用的都是同一個info

代碼 Info_t *info= (Info_t *)malloc(sizeof(Info_t));只創建了一個info

pthread_create(&threads[i],NULL,calMatrix,(void *)info); 三個線程使用的是同一個

我把你的代碼改了下：

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

intmtc[3]={0};//resultmatrix

typedefstruct
{
intprank;
int*mta;
int*mtb;
}Info_t;

void*calMatrix(void*arg)
{
inti;
Info_t*info=(Info_t*)arg;
intprank=info->prank;
fprintf(stdout,"calMatrix:prankis%d
",prank);

for(i=0;i<3;i++)
mtc[prank]+=info->mta[i]*info->mtb[i];

returnNULL;
}

intmain(intargc,char**argv)
{
inti,j,k=0;
intmta[3][3];
intmtb[3]={1};
Info_t*info=(Info_t*)malloc(sizeof(Info_t)*3);

for(i=0;i<3;i++)
for(j=0;j<3;j++)
mta[i][j]=k++;
/*3threads*/
pthread_t*threads=(pthread_t*)malloc(sizeof(pthread_t)*3);
fprintf(stdout,"
");fflush(stdout);
for(i=0;i<3;i++)
{
info[i].prank=i;
info[i].mta=mta[i];
info[i].mtb=mtb;
pthread_create(&threads[i],NULL,calMatrix,(void*)(&info[i]));
}
for(i=0;i<3;i++)
pthread_join(threads[i],NULL);

fprintf(stdout,"
====thematrixresult====

");
fflush(stdout);

for(i=0;i<3;i++)
{
fprintf(stdout,"mtc[%d]=%d
",i,mtc[i]);
fflush(stdout);
}
return0;
}

矩陣的計算我忘記了，你運行看看結果對不對

『玖』 linux的C語言開線程後如何歸還使用的內存

線程自身用的內存，是在棧上系統自動分配，或自己配置（操作系統提供了可編程配置參數，但也是操作系統在管理）。線程運行完成後返回棧內存操作系統會自動回收。需要注意的是，如果是在線程運行中中，使用malloc或操作系統的內存分配函數分配的內存，需要在線程返回前或返回後顯示釋放。自己編寫代碼，顯示調用free或操作系統提供的內存釋放函數。

『拾』 我是一個C++程序員，現在想在linux下寫多線程，一定要用C來寫嗎我對C有抵觸情緒

多線程的API是c的，沒辦法，但是，在開始的時候，一般會將其封閉為C++線程類，當然，可以自己去封裝，也可以使用開源的第三方庫。