c语言linux多线程
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
线程的划分尺度小于进程，使得多线程程序的并发性搞。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。
一般你运行一个应用程序,就生成了一个进程, 这个进程拥有自己的内存空间,
这个进程还可以内部生成多个线程, 这些线程之间共用一个进程的内存空存空间,所以线程之间共享内存是很容易做到的,多线程协作比多进程协作快一些,而且安全.
在windows跟unix上面,进程,线程的实现方法都是不一样的.
⑵ 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_*/
⑶ 用C语言在windows或者Linux上面，编写一个多线程程序
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int *pt=(int*)lpParam;
printf("I am tread %d\r\n",*pt);
}
int main()
{
const int Count=4;
int datas[Count];
DWORD dwThreadId[Count];
HANDLE hThread[Count];
int i;
for(i=0;i<Count;i++)
{
datas[i]=i+1;
hThread[i]=CreateThread(NULL,0,ThreadProc,&datas[i],0,&dwThreadId[i]);
}
WaitForMultipleObjects(Count,hThread,TRUE,INFINITE);
for(i=0;i<Count;i++)
{
CloseHandle(hThread[i]);
}
system("PAUSE");
return EXIT_SUCCESS;
}
⑷ c语言实现多线程
目录：
Linux操作系统，C语言实现多线程
Windows操作系统，C语言实现多线程
Windows下的多线程（不带停止）
Linux操作系统，C语言实现多线程：
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
void*ThreadOne(void*threadArg)
{
printf("线程开始啦，参数是：%s ",(char*)threadArg);
returnNULL;
}
intmain(void)
{
pthread_tThreadID;/*记录线程标识符*/
void*waitingResult;/*等待线程退出的等待结果*/
interrorCode;/*记录线程的错误代码*/
char*aMessage="这是线程的参数";
/*创建并启动线程ThreadOne。若返回值非零，则线程创建失败*/
errorCode=pthread_create(&ThreadID,NULL,ThreadOne,aMessage);
if(errorCode!=0)
{
printf("线程ThreadOne创建失败。错误代码：%d ",errorCode);
returnEXIT_FAILURE;
}
/*等待线程标识符为的ThreadID的线程结束*/
errorCode=pthread_join(ThreadID,&waitingResult);
if(errorCode!=0)
{
printf("等待线程退出等待失败。错误代码：%d ",errorCode);
returnEXIT_FAILURE;
}
printf("线程的返回值是%p ",waitingResult);
returnEXIT_SUCCESS;
}
Windows操作系统，C语言实现多线程：
#include<stdio.h>
#include<windows.h>
DWORDAPIENTRYThreadOne(LPVOIDthreadArg)
{
printf("线程开始啦，参数是：%s ",(char*)threadArg);
return0;
}
intmain(void)
{
HANDLEhThread;/*记录线程句柄*/
DWORDThreadID;/*记录线程ID号*/
DWORDwaitingResult;/*等待线程退出的等待结果*/
DWORDthreadExitCode;/*记录线程的返回值*/
char*aMessage="这是线程的参数";
/*创建并启动线程ThreadOne，返回值为线程句柄，赋值给hThread*/
hThread=CreateThread(NULL,0L,ThreadOne,(LPVOID)aMessage,0L,&ThreadID);
if(hThread==NULL)
{
printf("线程ThreadOne创建失败。错误代码：%lu ",GetLastError());
returnEXIT_FAILURE;
}
/*等待线程句柄为的hThread线程结束*/
waitingResult=WaitForSingleObject(hThread,INFINITE);
if(waitingResult==WAIT_FAILED)
{
printf("等待线程退出等待失败。错误代码：%lu ",GetLastError());
returnEXIT_FAILURE;
}
if(GetExitCodeThread(hThread,&threadExitCode))
printf("线程的返回值是%lu ",threadExitCode);
else
printf("获取线程的返回值获取失败。错误代码：%lu ",GetLastError());
returnEXIT_SUCCESS;
}
Windows下的多线程：（不带停止）
#include<stdio.h>
#include<windows.h>
DWORDWINAPIoxianchen(LPVOIDlpParam);
intmain(intargc,char*argv[])
{
intnum=0;
CreateThread(NULL,NULL,oxianchen,&num,NULL,NULL);
while(1)
{
num++;
printf("主线程!%05d ",nu***eep(40);
}
return0;
}
DWORDWINAPIoxianchen(LPVOIDlpParam)
{
int*a=lpParam;
while(1)
{
++*a;
printf("副线程!%05d0x%p ",*a,a);
Sleep(80);
}
return0;
}
⑸ Linux下C语言利用多线程向链表中写值
#include #include #include typedef struct datanode {char name[24];char phone[12];// ......struct datanode *next;}*pNode,*LinkList,Node;LinkList getEmptyList() {LinkList head = (pNode)malloc(sizeof(Node));head->next = NULL;retur...
⑹ 求思路：linux C上多线程接收数据怎么进行存储
在Linux系统中使用C/C++进行多线程编程时，我们遇到最多的就是对同一变量的多线程读写问题，大多情况下遇到这类问题都是通过锁机制来处理，但这对程序的性能带来了很大的影响，当然对于那些系统原生支持原子操作的数据类型来说，我们可以使用原子操作来处理，这能对程序的性能会得到一定的提高。那么对于那些系统不支持原子操作的自定义数据类型，在不使用锁的情况下如何做到线程安全呢？本文将从线程局部存储方面，简单讲解处理这一类线程安全问题的方法。
一、数据类型
在C/C++程序中常存在全局变量、函数内定义的静态变量以及局部变量，对于局部变量来说，其不存在线程安全问题，因此不在本文讨论的范围之内。全局变量和函数内定义的静态变量，是同一进程中各个线程都可以访问的共享变量，因此它们存在多线程读写问题。在一个线程中修改了变量中的内容，其他线程都能感知并且能读取已更改过的内容，这对数据交换来说是非常快捷的，但是由于多线程的存在，对于同一个变量可能存在两个或两个以上的线程同时修改变量所在的内存内容，同时又存在多个线程在变量在修改的时去读取该内存值，如果没有使用相应的同步机制来保护该内存的话，那么所读取到的数据将是不可预知的，甚至可能导致程序崩溃。
如果需要在一个线程内部的各个函数调用都能访问、但其它线程不能访问的变量，这就需要新的机制来实现，我们称之为Static memory local to a thread (线程局部静态变量)，同时也可称之为线程特有数据（TSD: Thread-Specific Data）或者线程局部存储（TLS: Thread-Local Storage）。这一类型的数据，在程序中每个线程都会分别维护一份变量的副本()，并且长期存在于该线程中，对此类变量的操作不影响其他线程。如下图：
二、一次性初始化
在讲解线程特有数据之前，先让我们来了解一下一次性初始化。多线程程序有时有这样的需求：不管创建多少个线程，有些数据的初始化只能发生一次。列如：在C++程序中某个类在整个进程的生命周期内只能存在一个实例对象，在多线程的情况下，为了能让该对象能够安全的初始化，一次性初始化机制就显得尤为重要了。——在设计模式中这种实现常常被称之为单例模式（Singleton）。Linux中提供了如下函数来实现一次性初始化：
#include <pthread.h>
// Returns 0 on success, or a positive error number on error
int pthread_once (pthread_once_t *once_control, void (*init) (void));
利用参数once_control的状态，函数pthread_once()可以确保无论有多少个线程调用多少次该函数，也只会执行一次由init所指向的由调用者定义的函数。init所指向的函数没有任何参数，形式如下：
void init (void)
{
// some variables initializtion in here
}
另外，参数once_control必须是pthread_once_t类型变量的指针，指向初始化为PTHRAD_ONCE_INIT的静态变量。在C++0x以后提供了类似功能的函数std::call_once ()，用法与该函数类似。使用
⑺ linux下c语言多线程拷贝文件出现问题，有时候会拷贝成功，有时候会失败，求原因
如果针对问的问题来说,可以考虑使用同步机制.可以查如mutex等同步机制.另外,我会建议你应该使用单一个服务程序,用缓存空间去接收要打印的讯息,单一控制输出萤幕,这样应该会比较好.因为萤幕输出只有一个,多线直接控制,本来就不好处理.如果采用传送讯息机制,应该就有顺序分别,不易产生问题.
⑻ 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;
}
矩阵的计算我忘记了，你运行看看结果对不对