执行一个 ，但是只要任何修改，都造成分裂如，修改了chroot,写memory，mmap，sigaction 等。
p1 是一个 task_struct, p2 也是一个 task_struct. linux内核的调度器只认得task_struck （不管你是进程还是线程）, 对其进行调度。
p2 的task_struck 被创建出来后，也有一份自己的资源。但是这些资源会短暂的与p1 相同。
进程是区分资源的单位，你的资源是我的资源，那从概念上将就不叫进程。
其他资源都好分配，唯一比较难的是内存资源的重新分配。
非常简单的程序，但是可以充分说明 COW。
结果：10 -> 20 -> 10
COW 是严重依赖于CPU中的MMU。CPU如果没有 MMU,fork 是不能工作的。
在没有mmu的CPU中，不可能执行COW 的，所以只有vfork
vfork与fork相比的不同
P2没有自己的 task_struct, 也就是说P1 的内存资源 就是 P2的内存资源。
结果 10,20,20
vfork：
vfork 执行上述流程，P2也只是指向了P1的mm，那么将这个vfork 放大，其余的也全部clone，共同指向P1，那么就是线程的属性了。
phtread_create -> Clone()
P1 P2 在内核中都是 task_struct. 都可以被调度。共享资源可调度，即线程。 这就是线程为什么也叫做轻量级进程
不需要太纠结线程和进程的区别。
4651 ： TGID
4652, 4653 tid 内核中 task_struct 真正的pid
linux 总是白发人 送 黑发人。如果父进程在子进程推出前挂掉了。那么子进程应该怎么办？
p3 -> init， p5 -> subreaper
每一个孤儿都会找最近的火葬场
可以设置进程的属性，将其变为subreaper，会像1号进程那样收养孤儿进程。
linux的进程睡眠依靠等待队列，这样的机制类似与涉及模式中的订阅与发布。
睡眠，分两种
每一个进程都是创建出来的，那么第一个进程是谁创建的呢？
init 进程是被linux的 0 进程 创建出来的。开机创建。
父进程就是 0 号进程，但在pstree，是看不到0进程的。因为0进程创建子进程后，就退化成了idle进程。
idle进程是 linux内核里，特殊调度类。 所有进程都睡眠停止 ，则调度idle进程，进入到 wait for interrupte 等中断。此时 cpu及其省电，除非来一个中断，才能再次被唤醒。
唤醒后的任何进程，从调度的角度上说，都比idle进程地位高。idle是调度级别最最低的进程。
0 进程 一跑，则进入等中断。一旦其他进程被唤醒，就轮不到 0进程了。
所有进程都睡了，0就上来，则cpu需要进入省电模式
Ⅱ 怎样查看Linux进程线程
linux怎么查看进程线程？我们一起来了解一下吧。
1、打开linux系统，在linux的桌面的空白处右击。
2、在弹出的下拉选项里，点击打开终端。
3、使用命令ps-T-p+进程ID可以查看指定线程。
4、使用top-H命令可以查看所有线程。
Ⅲ linux系统下 L可执行程序，进程，线程之间有什么区别_I,请高手回答，自己的理解感谢分享！
通俗的讲：
可执行程序就是可以运行的应用程序(application)，
进程是指application的调入系统内存中的进行资源分配和调度的独立单位，核心是进程控制块(PCB)
线程是指进程的实体，是CPU调度和分配的基本单元，核心是线程控制块(TCP)。
最直接的区别是(可执行程序[application]-->进程[Process]-->线程[Thread])。
Ⅳ Linux多进程和线程同步的几种方式
Linux 线程同步的三种方法
线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。
一、互斥锁(mutex)
通过锁机制实现线程间的同步。
初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。
静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);
加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。
int pthread_mutex_unlock(pthread_mutex_t *mutex);
销毁锁。锁在是使用完成后，需要进行销毁以释放资源。
int pthread_mutex_destroy(pthread_mutex *mutex);
[csharp] view plain
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <pthread.h>
#include "iostream"
using namespace std;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tmp;
void* thread(void *arg)
{
cout << "thread id is " << pthread_self() << endl;
pthread_mutex_lock(&mutex);
tmp = 12;
cout << "Now a is " << tmp << endl;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main()
{
pthread_t id;
cout << "main thread id is " << pthread_self() << endl;
tmp = 3;
cout << "In main func tmp = " << tmp << endl;
if (!pthread_create(&id, NULL, thread, NULL))
{
cout << "Create thread success!" << endl;
}
else
{
cout << "Create thread failed!" << endl;
}
pthread_join(id, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
//编译：g++ -o thread testthread.cpp -lpthread
二、条件变量(cond)
互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。
初始化条件变量。
静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER;
动态初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
等待条件成立。释放锁,同时阻塞等待条件变量为真才行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);
激活条件变量。pthread_cond_signal,pthread_cond_broadcast（激活所有等待线程）
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞
清除条件变量。无线程等待,否则返回EBUSY
int pthread_cond_destroy(pthread_cond_t *cond);
[cpp] view plain
#include <stdio.h>
#include <pthread.h>
#include "stdlib.h"
#include "unistd.h"
pthread_mutex_t mutex;
pthread_cond_t cond;
void hander(void *arg)
{
free(arg);
(void)pthread_mutex_unlock(&mutex);
}
void *thread1(void *arg)
{
pthread_cleanup_push(hander, &mutex);
while(1)
{
printf("thread1 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread1 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(4);
}
pthread_cleanup_pop(0);
}
void *thread2(void *arg)
{
while(1)
{
printf("thread2 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread2 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main()
{
pthread_t thid1,thid2;
printf("condition variable study!\n");
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
pthread_create(&thid1, NULL, thread1, NULL);
pthread_create(&thid2, NULL, thread2, NULL);
sleep(1);
do
{
pthread_cond_signal(&cond);
}while(1);
sleep(20);
pthread_exit(0);
return 0;
}
[cpp] view plain
#include <pthread.h>
#include <unistd.h>
#include "stdio.h"
#include "stdlib.h"
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node
{
int n_number;
struct node *n_next;
}*head = NULL;
static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n");
free(arg);
(void)pthread_mutex_unlock(&mtx);
}
static void *thread_func(void *arg)
{
struct node *p = NULL;
pthread_cleanup_push(cleanup_handler, p);
while (1)
{
//这个mutex主要是用来保证pthread_cond_wait的并发性
pthread_mutex_lock(&mtx);
while (head == NULL)
{
//这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何
//这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线
//程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。
//这个时候，应该让线程继续进入pthread_cond_wait
// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，
//然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立
//而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源
//用这个流程是比较清楚的
pthread_cond_wait(&cond, &mtx);
p = head;
head = head->n_next;
printf("Got %d from front of queue/n", p->n_number);
free(p);
}
pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁
}
pthread_cleanup_pop(0);
return 0;
}
int main(void)
{
pthread_t tid;
int i;
struct node *p;
//子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而
//不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大
pthread_create(&tid, NULL, thread_func, NULL);
sleep(1);
for (i = 0; i < 10; i++)
{
p = (struct node*)malloc(sizeof(struct node));
p->n_number = i;
pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，
p->n_next = head;
head = p;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mtx); //解锁
sleep(1);
}
printf("thread 1 wanna end the line.So cancel thread 2./n");
//关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出
//线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。
pthread_cancel(tid);
pthread_join(tid, NULL);
printf("All done -- exiting/n");
return 0;
}
三、信号量(sem)
如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。
信号量初始化。
int sem_init (sem_t *sem , int pshared, unsigned int value);
这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。
等待信号量。给信号量减1，然后等待直到信号量的值大于0。
int sem_wait(sem_t *sem);
释放信号量。信号量值加1。并通知其他等待线程。
int sem_post(sem_t *sem);
销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。
int sem_destroy(sem_t *sem);
[cpp] view plain
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <errno.h>
#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}
typedef struct _PrivInfo
{
sem_t s1;
sem_t s2;
time_t end_time;
}PrivInfo;
static void info_init (PrivInfo* thiz);
static void info_destroy (PrivInfo* thiz);
static void* pthread_func_1 (PrivInfo* thiz);
static void* pthread_func_2 (PrivInfo* thiz);
int main (int argc, char** argv)
{
pthread_t pt_1 = 0;
pthread_t pt_2 = 0;
int ret = 0;
PrivInfo* thiz = NULL;
thiz = (PrivInfo* )malloc (sizeof (PrivInfo));
if (thiz == NULL)
{
printf ("[%s]: Failed to malloc priv./n");
return -1;
}
info_init (thiz);
ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);
if (ret != 0)
{
perror ("pthread_1_create:");
}
ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);
if (ret != 0)
{
perror ("pthread_2_create:");
}
pthread_join (pt_1, NULL);
pthread_join (pt_2, NULL);
info_destroy (thiz);
return 0;
}
static void info_init (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
thiz->end_time = time(NULL) + 10;
sem_init (&thiz->s1, 0, 1);
sem_init (&thiz->s2, 0, 0);
return;
}
static void info_destroy (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
sem_destroy (&thiz->s1);
sem_destroy (&thiz->s2);
free (thiz);
thiz = NULL;
return;
}
static void* pthread_func_1 (PrivInfo* thiz)
{
return_if_fail(thiz != NULL);
while (time(NULL) < thiz->end_time)
{
sem_wait (&thiz->s2);
printf ("pthread1: pthread1 get the lock./n");
sem_post (&thiz->s1);
printf ("pthread1: pthread1 unlock/n");
sleep (1);
}
return;
}
static void* pthread_func_2 (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
while (time (NULL) < thiz->end_time)
{
sem_wait (&thiz->s1);
printf ("pthread2: pthread2 get the unlock./n");
sem_post (&thiz->s2);
printf ("pthread2: pthread2 unlock./n");
sleep (1);
}
return;
}
Ⅳ 麻烦解释一下linux下进程和线程有什么区别和联系，linux下多线程和多进程通信的实现方法，请通俗解释
兄弟看到你这么高的分我就找了些资料：也算是对昨天学的知识总结一下吧
一、先说概念不管是windows还是linux下的进程和线程概念都是一样的，只是管理进程和线程的方式不一样，这个是前提，到时候你可别问我windows下进程和线程啊。这个涉及到操作系统原理。下面给你解答。
说道进程不得不提作业这个名词 ，我想兄弟你电脑里不会有一个程序吧对不？当你的系统启动完毕后你看看你的任务管理器里是不是有很多进程呢？那么多程序是怎么调如内存呢？能理解吗？这里要明白程序和进程的关系，程序是你磁盘上的一个文件，当你需要它时进入内存后才成为进程，好比QQ在磁盘上就是一个文件而已，只有进入了内存才成为进程，进程是活动的。QQ要扫描你文件啊，记录你聊天记录啊，偷偷上传个啥东西什么的你也不知道对不，他是活动的。这个能明白吗？
再看作业，这个作业可不是你写作业的那个作业啊。系统一看好家伙你个QQ那么大的家伙你想一下子进入内存啊？没门！慢慢来嘛，系统就把QQ程序分为好几块，这几块不能乱分的，要符合自然结构就是循环啦选择啦这样的结构，你把人家循环结构咔嚓截断了，怎么让人家QQ运行啊？这就是作业要一块一块的进入内存，同时要为作业产生JCB（JOB CONTROL BLOCK)作业控制块，你进入内存不能乱跑啊，要听系统的话，你要是进入系统自己的内存。框一下，内存不能读写 对话框就出来了，严重点直接蓝脸给你！你懂得。这是window下的，linux下直接给你报错！没事了就！所一系统通过jcb控制进程。JCB包含了进程号优先级好多内容，你打开你的windows任务管理器看看进程是不是有好多属性啊？那就是PCB（PRCESS，CONTROL BLOCK）同理作业也包含那些内容只是多少而已。下面写出进程特点：
1、进程是分配计算机资源最小的单位。你想啊人是要用程序干活的吧？你把程序调入内存成了就成了进程，所以说进程是分配资源的最小单位。你在linux下打开终端输入top命令看是不是有好多进程？
2、进程有操作系统为作业产生。有“父进程”产生“子进程”之间是父子关系，并可以继续向下产生“子进程”。还拿QQ来说，你双击QQ.exe。QQ启动了输入账号密码打开主界面了。这时候你要聊天，QQ进程赶紧产生个“儿子”说 “儿子你去陪主人聊天去吧。这样子进程产生了。突然你想看美女要传照片这时候那个”儿子“有”生“了一个”儿子“说”儿子“你去传照片。那个“儿子领到任务去传照片了。这时你想关了QQ，QQ提示你说”你还有个“儿子”和“孙子”还在干活呢你真要结束吗？你蒽了确定。QQ对他“儿子”（你聊天窗口）说：”儿子啊对不起了，主人要关闭我你也不能活啊“咔嚓一下”儿子“死了，儿子死之前对他儿子说：“儿子啊你爷爷不让我活了，你也别活了咔嚓孙子也死了。最后世界安静了。这就是进程的父子关系。能明白吗？记住：进程之活动在内存中。不能使用CPU，只管分配资源。
再说线程：线程也产生在内存中并且在内存中存在相当长的时间，但它的活动区域主要在CPU中，并且运行和灭亡都存在于CPU中，可以这么说，线程是程序中能被系统调度进入CPU中最小程序单位，它能直接使用进程分配的CPU的资源。
还拿QQ来说当你要传文件时QQ总要判断一下文件的扩展名吧，ok这时那个”儿子“赶紧对它爸爸说我需要一个线程判断扩展名QQ赶紧对一个管这个的线程说：”快点去CPU里计算下那个扩展名是什么然后向主人报告计算完了就“死了”消亡了，但是它的线程还在内存中！还等着你下一次传文件然后计算然后消亡！
线程之间是相互独立的。一个在CPU，一个在内存里还能有关系吗对不？CPU在每一个瞬间只能进入一个线程，当线程进入CPU时立即产生一个新的线程，新线程仍停留在内存中，就好比上面那个传文件还会等着你再传文件再计算扩展名。
线程相对线程是独立的，但它在内存中并不是独立的，这就好比你不开QQ能用QQ传输文件吗？它只存在与进程分配的资源中，也就是说计算扩展名这个线程只能停留在QQ这个进程中，不能跑到别的进程里！！相当于程序产生了新的进程和线程，进程向CPU申请资源，再有线程来使用，他们都是为程序服务的只是分工不同！
因为你没提问linux下是怎么管理进程和线程的所以我就不回答了，这个问题我建议你还是看看《笨兔兔的故事》里面讲到了linux是怎么管理进程和线程的。挺幽默的比我说得还好。
你第二个问题说实话我回答不了你！我想你现在连进程和线程还没理解第二个你更理解不了了你说对不？我猜的其实你用C/C++不管是在windows下编程还是在Linux下编程思想都是一样的对吧，如果你理解了在windows下线程间通信，在linux更没问题了！
参考资料：黑客手册2009合订本非安全第一二季244页，245页，328页，329页，398页，399页
浅谈操作系统原理 （一 二三）
ubuntu中文论坛 笨兔兔的故事
http://forum.ubuntu.org.cn/viewtopic.php?f=120&t=267518
希望我的回答你能理解
Ⅵ 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线程的创建、退出、等待、取消、分离
返回值：成功：0，错误：出错编号。
pthread不是Linux系统默认的库而是POSIX线程库。在Linux中将其作为一个库来使用，因此编译时需要加上-pthread以显式链接该库
返回线程ID
线程标识符在进程中是唯一的，即分别属于两不同进程的两个线程可能有相同的线程标识符
retval:返回信息
参数表：
thread: 要等待的线程的pid
retval:用来存储被等待线程的返回值
返回0：成功；返回错误号：失败
主线程阻塞自己，等待子线程结束，然后回收子线程资源
可以设置线程能否被取消和取消后是否立即执行
参数表
state:PTHREAD_CANCEL_DISABLE或者PTHREAD_CANCEL_ENABLE
oldstate:指针类型，上一次取消状态的指针，可设NULL
type:PTHREAD_CANCEL_ASYNCHRONOUS立即取消
PTHREAD_CANCEL_DEFERRED等待事件（如pthread_join时）才取消
在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死,只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。 因此为了避免内存泄漏，所有线程的终止，要么已设为DETACHED，要么就需要使用pthread_join()来回收
返回0成功，错误号失败
分离后不可以再合并。该操作不可逆
综合以上要想让子线程总能完整执行（不会中途退出），
注：很多地方参照了黄茹老师主编的《Linux环境高级程序设计》
Ⅷ linux 下 进程和线程的区别
线程是指进程内的一个执行单元,也是进程内的可调度实体.
与进程的区别:
(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;
(2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
(3)线程是处理器调度的基本单位,但进程不是.
4)二者均可并发执行.
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体，是CPU调度和分派的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。
2.进程和应用程序的区别？
进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。
C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括： ●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间； ●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型； ●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令
3.进程与Java线程的区别
应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址，在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。
Java语言中定义的线程（Thread）同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行，它必须运行在处于活动状态的应用程序进程中，因此可以定义线程是程序内部的具有并发性的顺序代码流。 Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行，而Java语言支持应用程序进程内部的多个执行线程的并发执行。多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行，操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程，子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间，但保持每个线程拥有独立的执行堆栈和程序执行上下文（Context）。
需要注意的是：在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下，将Java程序划分为多个并发执行线程后，同时启动多个线程运行，使不同的线程运行在基于不同处理器的Java虚拟机中，才能提高应用程序的执行效率。 另外，如果应用程序必须等待网络连接或数据库连接等数据吞吐速度相对较慢的资源时，多线程应用程序是非常有利的。基于Internet的应用程序有必要是多线程类型的，例如，当开发要支持大量客户机的服务器端应用程序时，可以将应用程序创建成多线程形式来响应客户端的连接请求，使每个连接用户独占一个客户端连接线程。这样，用户感觉服务器只为连接用户自己服务，从而缩短了服务器的客户端响应时间。 三、Java语言的多线程程序设计方法
Ⅸ 在Linux下怎么修改当前线程的优先级
pthread_create()中的attr参数的__schedpolicy成员，表示新线程的调度策略，主要包括SCHED_OTHER（正常、非实时）、SCHED_RR（实时、轮转法）和SCHED_FIFO（实时、先入先出）三种，缺省为SCHED_OTHER，后两种调度策略仅对超级用户有效。运行时可以用过pthread_setschedparam()来改变。
__schedparam成员是一个struct sched_param结构，目前仅有一个sched_priority整型变量表示线程的运行优先级。这个参数仅当调度策略为实时（即SCHED_RR或SCHED_FIFO）时才有效，并可以在运行时通过pthread_setschedparam()函数来改变，缺省为0