linuxc线程
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
线程的划分尺度小于进程，使得多线程程序的并发性搞。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程（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,¶m);
param.__sched_priority=priority;
pthread_attr_setschedparam(&attr,¶m);
}
intThread::get_thread_priority(){
pthread_attr_getschedparam(&attr,¶m);
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++线程类，当然，可以自己去封装，也可以使用开源的第三方库。