Linux信号与线程
Ⅰ 麻烦解释一下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
希望我的回答你能理解
Ⅱ 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 多线程编程(二)2019-08-10
三种专门用于线程同步的机制:POSIX信号量,互斥量和条件变量.
在Linux上信号量API有两组,一组是System V IPC信号量,即PV操作,另外就是POSIX信号量,POSIX信号量的名字都是以sem_开头.
phshared参数指定信号量的类型,若其值为0,就表示这个信号量是当前进程的局部信号量,否则该信号量可以在多个进程之间共享.value值指定信号量的初始值,一般与下面的sem_wait函数相对应.
其中比较重要的函数sem_wait函数会以原子操作的方式将信号量的值减一,如果信号量的值为零,则sem_wait将会阻塞,信号量的值可以在sem_init函数中的value初始化;sem_trywait函数是sem_wait的非阻塞版本;sem_post函数将以原子的操作对信号量加一,当信号量的值大于0时,其他正在调用sem_wait等待信号量的线程将被唤醒.
这些函数成功时返回0,失败则返回-1并设置errno.
生产者消费者模型:
生产者对应一个信号量:sem_t procer;
消费者对应一个信号量:sem_t customer;
sem_init(&procer,2)----生产者拥有资源,可以工作;
sem_init(&customer,0)----消费者没有资源,阻塞;
在访问公共资源前对互斥量设置（加锁），确保同一时间只有一个线程访问数据，在访问完成后再释放（解锁）互斥量.
互斥锁的运行方式:串行访问共享资源;
信号量的运行方式:并行访问共享资源;
互斥量用pthread_mutex_t数据类型表示，在使用互斥量之前，必须使用pthread_mutex_init函数对它进行初始化，注意，使用完毕后需调用pthread_mutex_destroy.
pthread_mutex_init用于初始化互斥锁，mutexattr用于指定互斥锁的属性，若为NULL，则表示默认属性。除了用这个函数初始化互斥所外，还可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。
pthread_mutex_destroy用于销毁互斥锁，以释放占用的内核资源，销毁一个已经加锁的互斥锁将导致不可预期的后果。
pthread_mutex_lock以原子操作给一个互斥锁加锁。如果目标互斥锁已经被加锁，则pthread_mutex_lock则被阻塞，直到该互斥锁占有者把它给解锁.
pthread_mutex_trylock和pthread_mutex_lock类似，不过它始终立即返回，而不论被操作的互斥锁是否加锁，是pthread_mutex_lock的非阻塞版本.当目标互斥锁未被加锁时，pthread_mutex_trylock进行加锁操作；否则将返回EBUSY错误码。注意：这里讨论的pthread_mutex_lock和pthread_mutex_trylock是针对普通锁而言的，对于其他类型的锁，这两个加锁函数会有不同的行为.
pthread_mutex_unlock以原子操作方式给一个互斥锁进行解锁操作。如果此时有其他线程正在等待这个互斥锁，则这些线程中的一个将获得它.
三个打印机轮流打印:
输出结果:
如果说互斥锁是用于同步线程对共享数据的访问的话,那么条件变量就是用于在线程之间同步共享数据的值.条件变量提供了一种线程之间通信的机制:当某个共享数据达到某个值时,唤醒等待这个共享数据的线程.
条件变量会在条件不满足的情况下阻塞线程.且条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生.
其中pthread_cond_broadcast函数以广播的形式唤醒所有等待目标条件变量的线程,pthread_cond_signal函数用于唤醒一个等待目标条件变量线程.但有时候我们可能需要唤醒一个固定的线程,可以通过间接的方法实现:定义一个能够唯一标识目标线程的全局变量,在唤醒等待条件变量的线程前先设置该变量为目标线程,然后采用广播的方式唤醒所有等待的线程,这些线程被唤醒之后都检查该变量以判断是否是自己.
采用条件变量+互斥锁实现生产者消费者模型:
运行结果:
阻塞队列+生产者消费者
运行结果:
Ⅳ c语言实例，linux线程同步的信号量方式 谢谢
这么高的悬赏，实例放后面。信号量(sem),如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。
信号量初始化。
intsem_init(sem_t*sem,intpshared,unsignedintvalue);
这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。
等待信号量。给信号量减1，然后等待直到信号量的值大于0。
intsem_wait(sem_t*sem);
释放信号量。信号量值加1。并通知其他等待线程。
intsem_post(sem_t*sem);
销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。
intsem_destroy(sem_t*sem);
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<errno.h>
#definereturn_if_fail(p)if((p)==0){printf("[%s]:funcerror!/n",__func__);return;}
typedefstruct_PrivInfo
{
sem_ts1;
sem_ts2;
time_tend_time;
}PrivInfo;
staticvoidinfo_init(PrivInfo*thiz);
staticvoidinfo_destroy(PrivInfo*thiz);
staticvoid*pthread_func_1(PrivInfo*thiz);
staticvoid*pthread_func_2(PrivInfo*thiz);
intmain(intargc,char**argv)
{
pthread_tpt_1=0;
pthread_tpt_2=0;
intret=0;
PrivInfo*thiz=NULL;
thiz=(PrivInfo*)malloc(sizeof(PrivInfo));
if(thiz==NULL)
{
printf("[%s]:Failedtomallocpriv./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);
return0;
}
staticvoidinfo_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;
}
staticvoidinfo_destroy(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
sem_destroy(&thiz->s1);
sem_destroy(&thiz->s2);
free(thiz);
thiz=NULL;
return;
}
staticvoid*pthread_func_1(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s2);
printf("pthread1:pthread1getthelock./n");
sem_post(&thiz->s1);
printf("pthread1:pthread1unlock/n");
sleep(1);
}
return;
}
staticvoid*pthread_func_2(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s1);
printf("pthread2:pthread2gettheunlock./n");
sem_post(&thiz->s2);
printf("pthread2:pthread2unlock./n");
sleep(1);
}
return;
}
Ⅳ linux下 进程信号量和线程信号量的区别和联系是什么
信号量在进程是以有名信号量进行通信的，在线程是以无名信号进行通信的，因为线程linux还没有实现进程间的通信，所以在sem_init的第二个参数要为0，而且在多线程间的同步是可以通过有名信号量也可通过无名信号，但是一般情况线程的同步是无名信号量，无名信号量使用简单，而且sem_t存储在进程空间中，有名信号量必须LINUX内核管理，由内核结构struct ipc_ids 存储，是随内核持续的，系统关闭，信号量则删除，当然也可以显示删除，通过系统调用删除，
消息队列，信号量，内存共享，这几个都是一样的原理。，只不过信号量分为有名与无名
Ⅵ Linux中，shell脚本如何使用信号机制去控制线程的开启关闭
trap是Linux的内建命令，用于捕捉信号，trap命令可以指定收到某种信号时所执行的命令。trap命令的格式如下：trap command sig1 sig2 ... sigN，当接收到sinN中任意一个信号时，执行command命令，command命令完成后继续接收到信号前的操作，直到脚本结束。利用trap命令捕捉INT信号（即与Ctrl+c绑定的中断信号）。trap还可以忽略某些信号，将command用空字符串代替即可，如trap "" TERM INT，忽略kill %n和Ctrl+c发送的信号（kill发送的是TERM信号）。Linux更强劲的杀死进程的命令：kill -9 进程号（或kill -9 %n作业号）等价与kill -KILL 进程号。
举个例子：
最近小A需要生产2015年全年的KPI数据报表，现在小A已经将生产脚本写好了，生产脚本一次只能生产指定一天的KPI数据，假设跑一次生产脚本需要5分钟，那么：
如果是循环顺序执行，那么需要时间：5 * 365 = 1825 分钟，约等于 6 天
如果是一次性放到linux后台并发执行，365个后台任务，系统可承受不住哦！
既然不能一次性把365个任务放到linux后台执行，那么，能不能实现自动地每次将N个任务放到后台并发执行呢？当然是可以的啦。
#!/bin/bash
source/etc/profile;
#-----------------------------
tempfifo=$$.fifo#$$表示当前执行文件的PID
begin_date=$1#开始时间
end_date=$2#结束时间
if[$#-eq2]
then
if["$begin_date">"$end_date"]
then
echo"Error!$begin_dateisgreaterthan$end_date"
exit1;
fi
else
echo"Error!Notenoughparams."
echo"Sample:shloop_kpi2015-12-012015-12-07"
exit2;
fi
#-----------------------------
trap"exec1000>&-;exec1000<&-;exit0"2
mkfifo$tempfifo
exec1000<>$tempfifo
rm-rf$tempfifo
for((i=1;i<=8;i++))
do
echo>&1000
done
while[$begin_date!=$end_date]
do
read-u1000
{
echo$begin_date
hive-fkpi_report.sql--hivevardate=$begin_date
echo>&1000
}&
begin_date=`date-d"+1day$begin_date"+"%Y-%m-%d"`
done
wait
echo"done!!!!!!!!!!"
第6～22行：比如：sh loop_kpi_report.sh 2015-01-01 2015-12-01：
$1表示脚本入参的第一个参数，等于2015-01-01
$2表示脚本入参的第二个参数，等于2015-12-01
$#表示脚本入参的个数，等于2
第13行用于比较传入的两个日期的大小，>是转义
第26行：表示在脚本运行过程中，如果接收到Ctrl+C中断命令，则关闭文件描述符1000的读写，并正常退出
exec 1000>&-;表示关闭文件描述符1000的写
exec 1000<&-;表示关闭文件描述符1000的读
trap是捕获中断命令
第27～29行：
第27行，创建一个管道文件
第28行，将文件描述符1000与FIFO进行绑定，<读的绑定，>写的绑定，<>则标识对文件描述符1000的所有操作等同于对管道文件$tempfifo的操作
第29行，可能会有这样的疑问：为什么不直接使用管道文件呢？事实上这并非多此一举，管道的一个重要特性，就是读写必须同时存在，缺失某一个操作，另一个操作就是滞留，而第28行的绑定文件描述符（读、写绑定）正好解决了这个问题
第31～34行：对文件描述符1000进行写入操作。通过循环写入8个空行，这个8就是我们要定义的后台并发的线程数。为什么是写空行而不是写其它字符？因为管道文件的读取，是以行为单位的
第37～42行：
第37行，read -u1000的作用就是读取管道中的一行，在这里就是读取一个空行；每次读取管道就会减少一个空行
第39～41行，注意到第42行结尾的&吗？它表示进程放到linux后台中执行
第41行，执行完后台任务之后，往文件描述符1000中写入一个空行。这是关键所在了，由于read -u1000每次操作，都会导致管道减少一个空行，当linux后台放入了8个任务之后，由于文件描述符1000没有可读取的空行，将导致read -u1000一直处于等待。
Ⅶ Linux 中有名信号量,异常关闭其他线程如何获取
linux下进程间同步的机制有以下三种：
信号量
记录锁(文件锁)
共享内存中的mutex
效率上 共享内存mutex > 信号量 > 记录锁
posix 提供了新的信号量 - 有名信号量，既可以使用在进程间同步也可以作为线程间同步的手段。效率比共享内存mutex要好一些
Ⅷ Linux线程及同步
linux多线程
1.线程概述
线程是一个进程内的基本调度单位，也可以称为轻量级进程。线程是在共享内存空间中并发的多道执行路径，它们共享一个进程的资源，如文件描述和信号处理。因此，大大减少了上下文切换的开销。一个进程可以有多个线程，也就
是有多个线程控制表及堆栈寄存器，但却共享一个用户地址空间。
2.线程实现
线程创建pthread_create()
所需头文件#include
<pthread.h>
函数原型int
pthread_create
((pthread_t
*thread,
pthread_attr_t
*attr,
thread：线程标识符
attr：线程属性设置
start_routine：线程函数的起始地址
arg：传递给start_routine的参数
函数返回值
成功：0
出错：-1
线程退出pthread_exit();
所需头文件#include
<pthread.h>
函数原型void
pthread_exit(void
*retval)
函数传入值retval:pthread_exit()调用者线程的返回值，可由其他函数如pthread_join
来检索获取
等待线程退出并释放资源pthread_join()
所需头文件#include
<pthread.h>
函数原型int
pthread_join
((pthread_t
th,
void
**thread_return))
函数传入值
th：等待线程的标识符
thread_return：用户定义的指针，用来存储被等待线程的返回值（不为NULL时）
函数返回值
成功：0
出错：-1
代码举例
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
/*线程1*/
6.
void
thread1()
7.
{
8.
int
i=0;
9.
10.
while(1)
11.
{
12.
printf(thread1:%d/n,i);
13.
if(i>3)
14.
pthread_exit(0);
15.
i++;
16.
sleep(1);
17.
}
18.
}
19.
20.
/*线程2*/
21.
void
thread2()
22.
{
23.
int
i=0;
24.
25.
while(1)
26.
{
27.
printf(thread2:%d/n,i);
28.
if(i>5)
29.
pthread_exit(0);
30.
i++;
31.
sleep(1);
32.
}
33.
}
34.
35.
int
main()
36.
{
37.
pthread_t
t1,t2;
38.
39.
/*创建线程*/
40.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
41.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
42.
/*等待线程退出*/
43.
pthread_join(t1,NULL);
44.
pthread_join(t2,NULL);
45.
return
0;
46.
}
3同步与互斥
<1>互斥锁
互斥锁的操作主要包括以下几个步骤。
•
互斥锁初始化：pthread_mutex_init
•
互斥锁上锁：pthread_mutex_lock
•
互斥锁判断上锁：pthread_mutex_trylock
•
互斥锁接锁：pthread_mutex_unlock
•
消除互斥锁：pthread_mutex_destroy
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;/*共享变量*/
6.
pthread_mutex_t
mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥锁*/
7.
8.
void
thread1()
9.
{
10.
int
ret;
11.
while(1)
12.
{
13.
14.
15.
ret=pthread_mutex_trylock(&mutex);/*判断上锁*/
16.
17.
if(ret!=EBUSY)
18.
{
19.
pthread_mutex_lock(&mutex);/*上锁*/
20.
printf(This
is
thread1:%d/n,i);
21.
i++;
22.
pthread_mutex_unlock(&mutex);/*解锁*/
23.
}
24.
sleep(1);
25.
}
26.
}
27.
28.
void
thread2()
29.
{int
ret;
30.
while(1)
31.
{
32.
33.
ret=pthread_mutex_trylock(&mutex);
34.
if(ret!=EBUSY)
35.
{
36.
pthread_mutex_lock(&mutex);
37.
printf(This
is
thread2:%d/n,i);
38.
i++;
39.
pthread_mutex_unlock(&mutex);
40.
}
41.
sleep(1);
42.
}
43.
}
44.
int
main()
45.
{
46.
pthread_t
t1,t2;
47.
pthread_mutex_init(&mutex,NULL);
48.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
49.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
50.
51.
pthread_join(t1,NULL);
52.
pthread_join(t2,NULL);
53.
54.
pthread_mutex_destroy(&mutex);
55.
return
0;
56.
}
<2>信号量
未进行同步处理的两个线程
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;
6.
void
thread1()
7.
{
8.
9.
while(1)
10.
{
11.
printf(This
is
thread1:%d/n,i);
12.
i++;
13.
sleep(1);
14.
}
15.
}
16.
17.
18.
void
thread2()
19.
{
20.
21.
while(1)
22.
{
23.
printf(This
is
thread2:%d/n,i);
24.
i++;
25.
sleep(1);
26.
}
27.
}
28.
29.
int
main()
30.
{
31.
pthread_t
t1,t2;
32.
33.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
34.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
Ⅸ 有人能教下我有关linux里面线程的知识吗
.线程的基本介绍
(1)线程的概述
线程与进程类似，也允许应用程序并发执行多个任务的一种机制。一个进程可以包含多个线程，同一程序中的所有线程共享同一份全局内存区域，线程之间没有真正意义的等级之分。同一个进程中的线程可以并发执行，如果处理器是多核的话线程也可以并行执行，如果一个线程因为等待I/O操作而阻塞，那么其他线程依然可以继续运行
(2)线程优于进程的方面
argv,environ
主线程栈
线程3的栈
线程2的栈
线程1的栈
共享函数库共享的内存
堆
未初始化的数据段
初始化数据段
文本
.进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通讯，在进程之间交换信息
.调用fork()来创建进程代价相对较高
线程很好的解决了上述俩个问题
.线程之间能够方便，快速的共享信息，只需将数据复制到共享（全局或堆）变量中即可
.创建线程比创建线程通常要快10甚至更多，线程创建之所以快，是因为fork创建进程时所需复制多个属性，而在线程中，这些属性是共享的。
(3)创建线程
启动程序时，产生的进程只有单条线程，我们称之为主线程
#include<pthread.h>
int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void*(*start)(void *),void *arg);12
新线程通过调用带有arg的函数开始执行，调用pthread_create()的线程会继续执行该调用之后的语句。
(4)终止线程
可以以如下方式终止线程的运行
.线程调用pthread_exit()
.线程start函数执行return语句并返回指定值
.调用pthread_cancel()取消线程
.任意线程调用了exit(),或者主线程执行了return语句，都会导致进程中的所有线程立即终止
pthread_exit()函数可以终止线程，且其返回值可由另一线程通过调用pthread_join()获得
#include<pthread.h>void pthread_exit(void *retval);12
调用pthread_exit()相当于在线程的start函数中执行return,不同之处在于，pthread_exit()可以在任何地方调用，参数retval指定了线程的返回值
(5)获取线程ID
#include<pthread.h>pthread_t pthread_self(void);12
线程ID在应用程序中主要有如下用途
.不同的pthreads函数利用线程ID来标识要操作目标线程。
.在具体的应用程序中，以特定线程的线程ID作为动态数据结构的标签，这颇有用处，既可用来识别某个数据结构的创建者或属主线程，又可确定随后对该数据结构执行操作的具体线程
函数pthread_equal()可检查俩个线程的ID是否相同
#include<pthread.h>int pthread_equal(pthread_t t1,pthread_t t2);//如果相同返回非0值，否则返回0123
(6)连接已终止的线程
函数pthread_join()等待由thread表识的线程终止
#include<pthread.h>int pthread_join(pthread_t thread,void **retval);//返回0调用成功，否则失败123
如果pthread_join()传入一个之前已然连接过的线程ID，将会导致无法预知的行为，当相同线程ID在参与一次连接后恰好为另一新建线程所重用，再度连接的可能就是这个新线程
若线程未分离，则就应该使用pthread_join()来连接线程，否则会产生僵尸线程
pthrea_join()函数的要点
.线程之间的关系是对等的，所以任意线程都可以调用pthread_join()来连接其他线程
.pthread_join()无法针对任意线程，只能连接单个线程
(6)线程的分离
默认情况下线程都是可连接的，但有时候，我们并不关心线程退出的状态，我们可以调用pthread_detach()并向thread参数传入指定线程的的标识符，将该线程标记为处于分离状态
#include<pthread.h>int pthread_detach(pthread_t thread);//返回0成功，否则失败123
一旦线程处于分离状态，就不能在使用pthread_join()来获取其状态，也无法使其重返可连接状态
(7)在应用程序中如何来选择进程还是线程
.线程之间共享数据很简单，进程间的数据共享需要更多的投入
.创建线程要比创建进程块很多
.多线程编程时，需要确保调用线程安全的函数
.某个线程中的bug可能会危害进程中所有线程
.每个线程都在征用宿主进程中有限的虚拟地址空间
.在多线程应用中，需要小心使用信号
.除了数据，线程还可以共享文件描述符，信号处置，当前工作目录，以及用户ID和组ID
线程的同步
(1)保护共享变量访问：互斥量
线程的主要优势在于能够通过全局变量来共享信息，不过这种共享是有代价的。必须确保多个线程修改同一变量时，不会有其他线程也正在修改此变量，为避免线程更新时共享变量时所出现的问题，必须使用互斥量来确保同时仅有一个线程可以访问某项共享资源
(2)静态分配的互斥锁
互斥锁既可以像静态变量那样分配，也可以在运行时动态分配，互斥量属于pthread_mutex_t类型的变量，在使用之前必须对其初始化。对于静态分配的互斥量而言，可如下例所示，将PTHREAD_MUTEX_INITIALIZER赋给互斥量
pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER;1
1.加锁和解锁互斥量
初始化之后，互斥量处于未锁定状态。函数pthread_mutex_lock()可以锁定某一互斥量
而函数pthread_mutex_unlock()则可以将一个互斥量解锁
#include<pthread.h>int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);//返回0成功，其他失败1234
要锁定互斥量，在调用pthread_mutex_lock()时需要指定互斥量，如果互斥量当前处于未锁定状态，则该调用将会立即返回，如果该互斥量已被其他线程锁定，那么该调用将会阻塞，直至互斥量被解锁
函数pthread_mutex_unlock()将解锁之前已遭调用线程锁定的互斥量
2.互斥量的性能
通常情况下，线程会花费更多的时间去做其他工作，对互斥量的加锁解锁相对要少的多，因此使用互斥量对大部分程序来说性能并无显着的影响
3.互斥量的死锁
当一个线程需要同时访问多个共享资源时，没个资源由不同的互斥索管理。当超过一个线程加锁同一组互斥量时，就有可能发生死锁。如下图所示
线程A
1.pthread_mutex_lock(mutex1);
2.pthread_mutex_lock(mutex2);
线程2
1.pthread_mutex_lock(mutex2);
2.pthread_mutex_lock(mutex1);
每个线程都成功的锁住一个互斥量，接着试图对以为另一线程锁定的互斥量加锁，就会一直等下去
要避免此类死锁问题，最简单的就是定义互斥量的层级关系
Ⅹ Linux 的多线程编程中，如何给线程发信号
不管是在进程还是线程，很多时候我们都会使用一些定时器之类的功能，这里就定时器在多线程的使用说一下。首先在linux编程中定时器函数有alarm()和setitimer(),alarm()可以提供一个基于秒的定时功能，而setitimer可以提供一个基于微妙的定时功能。
alarm()原型：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
这个函数在使用上很简单，第一次调用这个函数的时候是设置定时器的初值，下一次调用是重新设置这个值，并会返回上一次定时的剩余时间。
setitimer()原型：
#include <sys/time.h>
int setitimer(int which, const struct itimerval *value,struct itimerval *ovalue);
这个函数使用起来稍微有点说法，首先是第一个参数which的值，这个参数设置timer的计时策略，which有三种状态分别是：
ITIMER_REAL：使用系统时间来计数，时间为0时发出SIGALRM信号，这种定时能够得到一个精准的定时，当然这个定时是相对的，因为到了微秒级别我们的处理器本身就不够精确。
ITIMER_VIRTUAL：使用进程时间也就是进程分配到的时间片的时间来计数，时间为0是发出SIGVTALRM信号，这种定时显然不够准确，因为系统给进程分配时间片不由我们控制。
ITIMER_PROF：上面两种情况都能够触发
第二个参数参数value涉及到两个结构体：
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
在结构体itimerval中it_value是定时器当前的值，it_interval是当it_value的为0后重新填充的值。而timeval结构体中的两个变量就简单了一个是秒一个是微秒。
上面是这两个定时函数的说明，这个函数使用本不是很难，可以说是很简单，但是碰到具体的应用的时候可能就遇到问题了，在多进程编程中使用一般不会碰到什么问题，这里说的这些问题主要体现在多线程编程中。比如下面这个程序：
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
void sig_handler(int signo)
{
alarm(2);
printf("alarm signal\n");
}
void *pthread_func()
{
alarm(2);
while(1)
{
pause();
}
}
int main(int argc, char **argv)
{
pthread_t tid;
int retval;
signal(SIGALRM, sig_handler);
if((retval = pthread_create(&tid, NULL, pthread_func, NULL)) < 0)
{
perror("pthread_create");
exit(-1);
}
while(1)
{
printf("main thread\n");
sleep(10);
}
return 0;
}
这个程序的理想结果是：
main thread
alarm signal
alarm signal
alarm signal
alarm signal
alarm signal
main thread
可事实上并不是这样的，它的结果是：
main pthread
alarm signal
main pthread
alarm signal
main pthread