Linux 线程

最新推荐文章于 2023-06-02 11:44:07 发布

alick97

最新推荐文章于 2023-06-02 11:44:07 发布

阅读量361

点赞数

分类专栏： Linux

本文链接：https://blog.csdn.net/alick97/article/details/52921653

版权

Linux 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

进程：资源分配的基本单位

线程：进程调度的基本单元

线程强调资源共享但不是一味的共享线程两个比较重要的私有成员：【1】必须有自己的硬件上下文进行自己切换时上下文的切换【2】私有栈结构

进程强调资源独占但不是一味的共享

各线程共享一下进程资源：

（1）文件描述符表

（2）每种信号的处理方式(SIG_IGN,SIG_DFL或者自定义的信号处理函数)

（3）当前工作目录

（4）用户id和组id

每个线程自己私有的数据：

（1）线程id

（2）上下文，包括各种寄存器的值、程序计数器和栈指针

（3）栈空间

（4）errno变量

（5）信号屏蔽字

（6）调度优先级

（地址空间就是资源）

只要进程能够共享地址空间并且分别执行共享空间的一部分就将这些进程叫做线程

在Linux中进程就是地址空间只有一个PCB的线程（单线程不能看成是进程因为线程的地址空间可以对应多个PCB）

所以Linux中所有的都可以看成是线程进程看成是独占资源的线程线程是轻量级的进程

Linux编程是不支持线程的，但可以利用别人提供的库来实现线程编程

函数：

 1） int pthread_create(pthread_t *thread, const pthread_attr_t *attr,     void *(*start_routine) (void *), void *arg);

作用：创建线程

参数：pthrea_t *thread 用于返回线程id

const pthread_attr_t *attr 表示线程属性可以传NULL

void *(*start_routine) (void *) 线程执行代码所在的函数的函数指针

void *arg 对应上面 void *(*start_routine) (void *) 函数指针的用到的参数 void*

返回值：成功返回0 失败返回错误码用strerror(错误码)将错误信息转化为字符串

  2）     void pthread_exit(void *retval);

           3）    int pthread_join(pthread_t thread, void **retval);

只有阻塞方式等待线程线程必须等待防止内存泄露

获得pthread_exit的retval返回值

       int pthread_detach(pthread_t thread);  // 分离

编译时由于线程是POSIX库的所以要在后面加上 -lpthread

否则报错

gcc -o pthread_creat pthread_creat.c
/tmp/ccPkLaUo.o: In function `main':
pthread_creat.c:(.text+0x71): undefined reference to `pthread_create'
collect2: ld 返回 1
make: *** [pthread_creat] 错误 1

因为他在

libpthread共享库中

gcc -o pthread_creat pthread_creat.c -lpthread

1） 创建线程:

练习代码：

#include<stdio.h>
#include <pthread.h>
#include <stdlib.h>
void* thread_run(void *arg)
{
    printf("%s: \npid is :%d, tid is : %u\n",(char*)arg,getpid(), pthread_self( ));
    sleep(20);
    //return (void*)256; // 线程的退出码可以超过255 进程的256 是0 NULL;
    pthread_exit(NULL);
//exit(3);  _exit(3) 这个所有线程 全部结束

}
int main()
{
    pthread_t id;
    int ret = pthread_create(&id, NULL, thread_run,"new thread run...");// NULL);
    if (ret == 0)
    {
        printf("create thread success\n");
    }
    else
    {
        printf("create thread error! info is :%s\n", strerror(ret));
        exit(ret);
    }
    while (1)
    {
        printf("main thread run...\n");
        sleep(5);
    }
    return 0;
}
运行结果：
[bozi@localhost thread]$ ./pthread_creat
create thread success
main thread run...
new thread run...:
pid is :4418, tid is : 3077688176
main thread run...
main thread run...

命令行查看：

[bozi@localhost test_20160726]$ ps -aL
 [bozi@localhost ~]$ ps -aL
  PID   LWP TTY          TIME CMD
 3114  3114 pts/5    00:00:00 vim
 3171  3171 pts/5    00:00:00 man
 3174  3174 pts/5    00:00:00 sh
 3175  3175 pts/5    00:00:00 sh
 3179  3179 pts/5    00:00:00 less
 4418  4418 pts/1    00:00:00 pthread_creat
 4418  4419 pts/1    00:00:00 pthread_creat
 4420  4420 pts/0    00:00:00 ps
32098 32098 pts/6    00:00:00 vim

LWP轻量级进程 cpu调度不以PID进程为基本单位而以LWP（线程）为基本单位【PID可以相同的多个存在但 LWP不一样多线程】

LWP在整个操作系统有效但线程中调用的 pthread_self()得到的线程id只在当前进程有效看不到全局的全局的LWP才是操作系统级别的。

由上面结果：PID4418由两个以PID区分线程是区分不开的但以LWP全局的线程ID是可以区分开的但是要注意在线程中调用pthread_self()得到的线程id

tid is : 3077688176与这个4418 4419是比一样的且 pthread_self()得到的只能在线程内部看到是一个局部性的

2）线程退出

在线程中不要调用exit exit会终止整个进程

线程退出：（1）调用return 退出码

（2）调用pthread_exit(退出码)

3）终止线程

3种方法：

1 从线程return 不适合main线程 main线程return 相当于调用exit

2 一个线程调用 pthread_cancel终止同一进程中的另一个线程

3 线程调用pthread_exit来终止自己

4）线程等待

函数： int pthread_join(pthread_t thread, void **retval)

成功返回0 失败返回错误号

pthread_join得到的进程的终止状态有3种

1 thread线程通过 return返回 value_ptr所指的空间存返回值

2 thread线程被别的线程调用pthread_cancel异常终止，value_ptr所指的空间存常数 'PTHREAD_CANCELED'

【grep -ER 'PTHREAD_CANCELED' /usr/include/

线程被取消一定退出码为 -1 这个-1其实是一个宏 PTHREAD_CANCELED -1

[bozi@localhost test_20160726]$ grep -ER 'PTHREAD_CANCELED' /usr/include/

/usr/include/pthread.h:#define PTHREAD_CANCELED ((void *) -1)

/usr/include/pthread.h: the thread as per pthread_exit(PTHREAD_CANCELED) if it has been】

3 thread线程自己调用pthread_exit终止 value_ptr所指的空间存pthread_exit的参数

练习代码：

#include<stdio.h>
#include <stdlib.h>
#include <pthread.h>
// return 返回
void* pthread1(void *_val)
{
    printf("thread 1 returning...\n");
    return (void*)1;
}
// pthread_exit返回
void* pthread2(void *_val)
{
    printf("thread 2 exiting...\n");
    pthread_exit((void*)2);
}
// 被其他进程 cancel
void* pthread3(void * _val)
{
    while (1)
    {
        printf("phread 3 is running, wait for be cancel...\n");
        sleep(1);
    }
    return NULL;
}
int main()
{
    pthread_t tid;
    void *tret;
    // thread 1 return
    pthread_create(&tid, NULL, pthread1,NULL);
    pthread_join(tid, &tret);
    printf("thread1 return , thread id is :%u, return code is :%d\n", (unsigned long)tid, (int)tret);
    //thread 2 exit
    pthread_create(&tid, NULL, pthread2, NULL);
    pthread_join(tid, &tret);
    printf("thread2 exit , thread id is: %u, exit code is :%d\n ",(unsigned long)tid, (int)tret);
    // thread 3 cancel by other
    pthread_create(&tid, NULL, pthread3, NULL);
    sleep(3);
    pthread_cancel(tid);
    pthread_join(tid, &tret);
    printf("thread3 cancel,thread id is :%u, cancel code is :%d\n", (unsigned long)tid, (int)tret);
    return 0;
}

运行结果：

[bozi@localhost thread]$ ./pthread_join
thread 1 returning...
thread1 return , thread id is :3077725040, return code is :1
thread 2 exiting...
thread2 exit , thread id is: 3077725040, exit code is :2
 phread 3 is running, wait for be cancel...
phread 3 is running, wait for be cancel...
phread 3 is running, wait for be cancel...
thread3 cancel,thread id is :3077725040, cancel code is :-1

5）线程分离

用 pthread_detach

int pthread_detach(pthread_t thread);

线程也可以被置为 detach 状态, 这样的线程一旦终止就立刻回收它占用的所有资源 ,

而不保留终止状态。不能对一个已经处于 detach状态的线程调用 pthread_join,这样的调用将

返回EINVAL。对一个尚未 detach的线程调用 pthread_join或pthread_detach 都可以把该线程

置为detach状态 ,也就是说 ,不能对同一线程调用两次 pthread_join,或者如果已经对一个线程调

用了 pthread_detach就不能再调用pthread_join了。

在任何一个时间点上， 线程是可结合的（ joinable）或者是分离的（detached）。一个可

结合的线程能够被其他线程收回其资源和杀死。在被其他线程回收之前，它的存储器资源

（例如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存

储器资源在它终止时由系统自动释放。

线程退出将退出信息保存在线程PCB中

return进程建议在非主线程中调用因为主线程的退出比较特殊主线程退出相当于进程退出其他线程也就退出

在代码中定义的全局变量进程之间都可以共享这样线程间通信比进程之间的通信简单的多

thread_detach 分离出去的线程还是属于进程的因为他的资源是进程提供的在进程中如果他调用exit 那么主进程还是会退出的

默认情况下，线程被创建成可结合的。 为了避免存储器泄漏，每个可结合线程都应该要

么被显示地回收，即调用 pthread_join；要么通过调用 pthread_detach函数被分离。

如果一个可结合线程结束运行但没有被 join，则它的状态类似于进程中的 Zombie Process，

即还有一部分资源没有被回收，所以创建线程者应该调用 pthread_join来等待线程运行结

束，并可得到线程的退出代码，回收其资源。

由于调用 pthread_join后，如果该线程没有运行结束，调用者会被阻塞 ，在有些情况下我

们并不希望如此。例如，在 Web服务器中当主线程为每个新来的连接请求创建一个子线程进

行处理的时候，主线程并不希望因为调用 pthread_join而阻塞（因为还要继续处理之后到来

的连接请求），

两种 detach的方法：

这时可以在子线程中加入代码

pthread_detach(pthread_self())

或者父线程调用

pthread_detach(thread_id)（非阻塞，可立即返回）

这将该子线程的状态设置为分离的（ detached），如此一来，该线程运行结束后会自动释

放所有资源。

练习代码：

#include<stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *thread_run(void * _val)
{
    //分离线程方法1  子线程 方法中 分离
//    pthread_detach(pthread_self());
    printf("thread  detached\n");
    printf("%s\n", (char*)_val);
    return NULL;
}
int main()
{
    pthread_t tid;
    int tret = pthread_create(&tid, NULL, thread_run, "thread1 run...");
    //分离线程方法2 主线程中 分离子线程
    pthread_detach(tid);   
    if (tret != 0)
    {
        printf("create thread error!, info is :%s\n", strerror(tret));
        return tret;
    }
    // wait
    int ret = 0;
    sleep(1);
    if (0 == pthread_join(tid, NULL))
    {
        printf("pthread wait success!\n");
        ret = 0;
    }
    else
    {
        printf("pthread wait falied!\n");
        ret = 1;
    }
    return ret;
}

运行结果;

[bozi@localhost thread]$ ./pthread_detach
thread  detached
thread1 run...
pthread wait falied!

6）线程同步：

（1）互斥量

对于多线程的程序 ,访问冲突的问题是很普遍的 ,解决的办法是引入互斥锁 (Mutex,Mutual

Exclusive Lock),获得锁的线程可以完成“读 -修改 -写 ”的操作, 然后释放锁给其它线程 ,没有获得

锁的线程只能等待而不能访问共享数据 ,这样 “读- 修改-写 ”三步操作组成一个原子操作 ,要么

都执行 ,要么都不执行 ,不会执行到中间被打断 ,也不会在其它处理器上并行做这个操作。

测试出现问题的代码（没对临界资源加锁）：

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
static int g_count = 0;
void * read_write_mem(void * _val)
{
    int val = 0;
    int i = 0;
    for (; i < 5000; i++)
    {
        val = g_count;
        printf("pthread id is %x, count is : %d\n", (unsigned long)pthread_self(), g_count); // printf 里面用到系统调用，因为显示器是外设，对外设的操作一定是操作系统。  这样就能产生进入内核的条件
          // 让内核进行其他工作的 这样就会出现问题 使得对 g_count 的操作不是原子的 
        g_count = val + 1;
        //g_count++;
    }
    return NULL;
}
int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, read_write_mem, NULL);
    pthread_create(&tid2, NULL, read_write_mem, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("count final val is : %d\n", g_count);
    return 0;
}

运行结果：

pthread id is b77d4b70, count is : 5176
pthread id is b77d4b70, count is : 5177
pthread id is b77d4b70, count is : 5178
pthread id is b77d4b70, count is : 5179
pthread id is b77d4b70, count is : 5180
pthread id is b77d4b70, count is : 5181
count final val is : 5182

解决：

用到的函数：

       int pthread_mutex_lock(pthread_mutex_t *mutex);
       int pthread_mutex_trylock(pthread_mutex_t *mutex);
       int pthread_mutex_unlock(pthread_mutex_t *mutex);
       #include <pthread.h>
       int pthread_mutex_destroy(pthread_mutex_t *mutex);
       int pthread_mutex_init(pthread_mutex_t *restrict mutex,
              const pthread_mutexattr_t *restrict attr);
       pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

一个线程可以调用 pthread_mutex_lock获得Mutex,如果这时另一个线程已经调用

pthread_mutex_lock获得了该Mutex,则当前线程需要挂起等待 ,直到另一个线程调用

pthread_mutex_unlock释放Mutex,当前线程被唤醒 ,才能获得该Mutex并继续执行。

如果一个线程既想获得锁 ,又不想挂起等待 ,可以调用 pthread_mutex_trylock, 如果Mutex 已

经被另一个线程获得 ,这个函数会失败返回 EBUSY, 而不会使线程挂起等待。

代码：

void * read_write_mem(void * _val)
{
    int val = 0;
    int i = 0;
    for (; i < 5000; i++)
    {
        pthread_mutex_lock(&mutex_lock); // 加锁
        val = g_count;
        printf("pthread id is %x, count is : %d\n", (unsigned long)pthread_self(), g_count);
        g_count = val + 1;
        pthread_mutex_unlock(&mutex_lock);
        //g_count++;
    }
    return NULL;
}
int main()
{
    pthread_mutex_init(&mutex_lock,NULL);
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, read_write_mem, NULL);
    pthread_create(&tid2, NULL, read_write_mem, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("count final val is : %d\n", g_count);
    pthread_mutex_destroy(&mutex_lock);
    return 0;
}

运行：

...
pthread id is b77e5b70, count is : 9995
pthread id is b77e5b70, count is : 9996
pthread id is b77e5b70, count is : 9997
pthread id is b77e5b70, count is : 9998
pthread id is b77e5b70, count is : 9999
count final val is : 10000

加锁的实现：

由于汇编层面支持 exchange 这条指令是原子的交换两个数的值

所以就有了加锁操作的实现

加锁建议; 能不加锁就不加锁万不得已加锁，以最简洁的方式加锁，避免复杂，降低产生死锁的条件。

(2) 条件变量

完成同步

用到的函数：

   int pthread_cond_destroy(pthread_cond_t *cond);
       int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);
       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
       int pthread_cond_timedwait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex,
              const struct timespec *restrict abstime);
       int pthread_cond_wait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex);
       int pthread_cond_broadcast(pthread_cond_t *cond);
       int pthread_cond_signal(pthread_cond_t *cond);

一个Condition Variable 总是和一个 Mutex搭配使用

pthread_cond_wait在一个Condition Variable上阻塞，函数需要做以下三步：

1）释放Mutex【因为之前申请锁如果自己直接阻塞那么生产者也就得不到锁所以要先释放锁】

2）阻塞等待

3）当被唤醒时，重新获得Mutex并返回

生产者消费者

1）两个角色消费者和消费者角色（线程担当）

2）1中生产场所（在这是链表）

3）3个条件生产者-生产者（互斥）消费者-消费者（互斥）消费者-生产者（同步）

练习代码【LIFO模式后进先出】:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
typedef struct _list
{
    struct _list *_next;
    int _val;
}product_list;
product_list* head = NULL;
static pthread_mutex_t lock;
static pthread_cond_t cond;
void init_list(product_list *list)
{
    if (list != NULL)
    {
        list->_next = NULL;
        list->_val = 0;
    }
}
void* consumer(void * _val)
{
    product_list *p = NULL;
    while (1)
    {
        pthread_mutex_lock(&lock);
        while (head == NULL)
        {
            pthread_cond_wait(&cond, &lock);
        }
        p = head;
        head = head->_next;
        p->_next = NULL;
        pthread_mutex_unlock(&lock);
        printf("consum success, val is : %d\n", p->_val);
        free(p);
        p = NULL;
    }
    return NULL;
}
void* product(void *_val)
{
    while (1)
    {
        sleep(1);
        product_list *p = malloc(sizeof(product_list));
        pthread_mutex_lock(&lock);
        init_list(p);
        p->_val = rand()%1000;
        p->_next = head;
        head = p;
        pthread_mutex_unlock(&lock);
        printf("call consumer! product success , val is : %d\n",head->_val);
        pthread_cond_signal(&cond);
    }
}
int main()
{
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_t t_product;
    pthread_t t_consumer;
    pthread_create(&t_product, NULL, product, NULL);
    pthread_create(&t_consumer, NULL, consumer, NULL);
    pthread_join(t_product, NULL);
    pthread_join(t_consumer, NULL);
    return 0;
}

运行结果：

[bozi@localhost test_20160730]$ ./consumer_producter
call consumer! product success , val is : 383
consum success, val is : 383
call consumer! product success , val is : 886
consum success, val is : 886
call consumer! product success , val is : 777
consum success, val is : 777
call consumer! product success , val is : 915
consum success, val is : 915
call consumer! product success , val is : 793
consum success, val is : 793

练习代码【FIFO模式先进先出】

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
/*LIFO*/
typedef struct _list
{
    struct _list *_next;
    int _val;
}product_list;
product_list* head = NULL;
static pthread_mutex_t lock;
static pthread_cond_t cond;
void init_list(product_list *list)
{
    if (list != NULL)
    {
        list->_next = NULL;
        list->_val = 0;
    }
}
static print_list(product_list * l)
{
    while (l != NULL)
    {
        printf("%d->", l->_val);
        l = l->_next;
    }
    printf("over\n");
}
void* consumer(void * _val)
{
    // 每次消费最后一个
    product_list *p = NULL;
    while (1)
    {
        sleep(2);
        pthread_mutex_lock(&lock);
        while (head == NULL)
        {
            printf("wait for product\n");
            pthread_cond_wait(&cond, &lock);
        }
        p = head;
        if (p == NULL)
        {
            pthread_mutex_unlock(&lock);
        }
        else if (p->_next == NULL )
        {
            head = NULL;
            printf("consum success, val is : %d\n", p->_val);
            pthread_mutex_unlock(&lock);
            free(p);
        }
        else
        {
            while(p->_next->_next != NULL)
            {
                p = p->_next;
            }
            printf("consum success, val is : %d\n", p->_next->_val);
            pthread_mutex_unlock(&lock);
            free(p->_next);
            p->_next = NULL;
        }
        print_list(head);
    }
    return NULL;
}
void* product(void *_val)
{
    while (1)
    {
        sleep(1);
        product_list *p = malloc(sizeof(product_list));
        pthread_mutex_lock(&lock);
        init_list(p);
        p->_val = rand()%1000;
        p->_next = head;
        head = p;
        pthread_mutex_unlock(&lock);
        printf("call consumer! product success , val is : %d\n",head->_val);
        pthread_cond_signal(&cond);
    }
}
int main()
{
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_t t_product;
    pthread_t t_consumer;
    pthread_create(&t_product, NULL, product, NULL);
    pthread_create(&t_consumer, NULL, consumer, NULL);
    pthread_join(t_product, NULL);
    pthread_join(t_consumer, NULL);
    return 0;
}

运行：

[bozi@localhost test_20160730]$ ./consumer_producter_multi
call consumer! product success , val is : 383
consum success, val is : 383
over
call consumer! product success , val is : 886
call consumer! product success , val is : 777
consum success, val is : 886
777->over
call consumer! product success , val is : 915
call consumer! product success , val is : 793
consum success, val is : 777
793->915->over
call consumer! product success , val is : 335
call consumer! product success , val is : 386
consum success, val is : 915
386->335->793->over
call consumer! product success , val is : 492
call consumer! product success , val is : 649
consum success, val is : 793
649->492->386->335->over
call consumer! product success , val is : 421

练习代码【多消费者多生产者】：

#include <pthread.h>
/*LIFO*/
typedef struct _list
{
    struct _list *_next;
    int _val;
}product_list;
product_list* head = NULL;
static pthread_mutex_t lock;
static pthread_cond_t cond;
void init_list(product_list *list)
{
    if (list != NULL)
    {
        list->_next = NULL;
        list->_val = 0;
    }
}
static print_list(product_list * l)
{
    while (l != NULL)
    {
        printf("%d->", l->_val);
        l = l->_next;
    }
    printf("over\n");
}
void* consumer(void * _val)
{
    // 每次消费最后一个
    product_list *p = NULL;
    while (1)
    {
        sleep(2);
        pthread_mutex_lock(&lock);
        while (head == NULL)
        {
            printf("%s tid :%u wait for product\n",(char*)_val,pthread_self());
            pthread_cond_wait(&cond, &lock);
        }
        p = head;
        if (p == NULL)
        {
            pthread_mutex_unlock(&lock);
        }
        else if (p->_next == NULL )
        {
            head = NULL;
            printf("%s tid :%u consum success, val is : %d\n",(char*)_val, pthread_self(),p->_val);
            pthread_mutex_unlock(&lock);
            free(p);
        }
        else
        {
            while(p->_next->_next != NULL)
            {
                p = p->_next;
            }
            printf("%s tid :%u consum success, val is : %d\n",(char*)_val, pthread_self(), p->_next->_val);
            pthread_mutex_unlock(&lock);
            free(p->_next);
            p->_next = NULL;
        }
        print_list(head);
    }
    return NULL;
}
void* product(void *_val)
{
    while (1)
    {
        sleep(1);
        product_list *p = malloc(sizeof(product_list));
        pthread_mutex_lock(&lock);
        init_list(p);
        p->_val = rand()%1000;
        p->_next = head;
        head = p;
        pthread_mutex_unlock(&lock);
        printf("%s tid :%u call consumer! product success , val is : %d\n",(char*)_val, pthread_self(),head->_val);
        //pthread_cond_signal(&cond);
        pthread_cond_broadcast(&cond);
    }
}
int main()
{
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_t t_product1;
    pthread_t t_product2;
    pthread_t t_consumer1;
    pthread_t t_consumer2;
    pthread_create(&t_product1, NULL, product, "p1");
    pthread_create(&t_product2, NULL, product, "p2");
    pthread_create(&t_consumer1, NULL, consumer, "c1");
    pthread_create(&t_consumer2, NULL, consumer, "c2");
    pthread_join(t_product1, NULL);
    pthread_join(t_product2, NULL);
    pthread_join(t_consumer1, NULL);
    pthread_join(t_consumer2, NULL);
    return 0;
}

运行：

[bozi@localhost test_20160730]$ make
gcc -o consumer_producter_multi consumer_producter_multi.c -lpthread
[bozi@localhost test_20160730]$ ./consumer_producter_multi
p2 tid :3067267952 call consumer! product success , val is : 383
p1 tid :3077757808 call consumer! product success , val is : 886
c1 tid :3056778096 consum success, val is : 383
886->over
c2 tid :3046288240 consum success, val is : 886
over
p2 tid :3067267952 call consumer! product success , val is : 777
p1 tid :3077757808 call consumer! product success , val is : 915
p2 tid :3067267952 call consumer! product success , val is : 793
p1 tid :3077757808 call consumer! product success , val is : 335
c1 tid :3056778096 consum success, val is : 777
335->793->915->over
c2 tid :3046288240 consum success, val is : 915
335->793->over
p2 tid :3067267952 call consumer! product success , val is : 386
p1 tid :3077757808 call consumer! product success , val is : 492
p2 tid :3067267952 call consumer! product success , val is : 649
p1 tid :3077757808 call consumer! product success , val is : 421
c1 tid :3056778096 consum success, val is : 793
421->649->492->386->335->over
c2 tid :3046288240 consum success, val is : 335
421->649->492->386->over
p2 tid :3067267952 call consumer! product success , val is : 362
p1 tid :3077757808 call consumer! product success , val is : 27
p2 tid :3067267952 call consumer! product success , val is : 690
p1 tid :3077757808 call consumer! product success , val is : 59

（3）Semaphore信号量

用到的函数：

 int sem_init(sem_t *sem, int pshared, unsigned int value);
               pshared为零 表示同一进程中的线程的同步
       int sem_wait(sem_t *sem);
       int sem_trywait(sem_t *sem);
       int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
       int sem_post(sem_t *sem);
       int sem_destroy(sem_t *sem);

用数组实现下面的循环链表

环形buf 生产者绝对不能将生产者围一圈这样就覆盖了别的数据

如何防止覆盖

生产者看重 space资源

消费者看重 data资源

练习代码【单生产者单消费者】：不需要加互斥锁因为一个生产者和一个消费者是不会区域重叠的

#include<stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define _SEM_PRO_ 5
#define _SEM_COM_ 0
sem_t sem_product;
sem_t sem_consume;
int bank[_SEM_PRO_];
void* consumer(void * _val)
{
    int c = 0;
    while (1)
    {
     sem_wait(&sem_consume);
        int _consume = bank[c];
        bank[c] = -5;
        printf("consume done..., val is : %d\n", _consume);
        sem_post(&sem_product);// 增加生产者的信号量
        c = (c + 1) % _SEM_PRO_;
    //    sleep(rand()%5);
    }
}
void* producter(void *_val)
{
    int p = 0;
    while (1)
    {
         sem_wait(&sem_product);
        int _product = rand() % 100;
        bank[p] = _product;
        printf("product done..., val is : %d\n",_product);
        sem_post(&sem_consume);// 增加消费者的信号量
        p = (p + 1)% _SEM_PRO_;
        sleep(rand()%2);
    }
}
void destroy_all_sem()
{
    printf("\nprocess done ...\n");
    sem_destroy(&sem_product);
    sem_destroy(&sem_consume);
    exit(155);
}
void init_all_sem()
{
    signal(2, destroy_all_sem);
    int i = 0;
    for (; i < _SEM_PRO_; i++)
    {
        bank[i] = 0;
    }
    sem_init(&sem_product, 0, _SEM_PRO_);
    sem_init(&sem_consume, 0 , _SEM_COM_);
}
void run_product_consume()
{
    pthread_t tid_consumer;
    pthread_t tid_producter;
    pthread_create(&tid_consumer, NULL, consumer, NULL);
    pthread_create(&tid_producter, NULL, producter, NULL);
    //pthread_exit((void *)2);
    pthread_join(tid_consumer, NULL);
    pthread_join(tid_producter, NULL);
}
int main()
{
    init_all_sem();
    run_product_consume();
    destroy_all_sem();
    return 0;
}

运行：

[bozi@localhost test_20160730]$ ./Semaphore
product done..., val is : 83
product done..., val is : 77
consume done..., val is : 83
consume done..., val is : 77
product done..., val is : 93
consume done..., val is : 93
^C
process done ...

练习代码【多生产者多消费者】：（在单消费者和单消费者的基础上加互斥锁）

#include<stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define _SEM_PRO_ 5
#define _SEM_COM_ 0
sem_t sem_product;
sem_t sem_consume;
int bank[_SEM_PRO_];
    int conindex = 0;
    int proindex = 0;
static pthread_mutex_t con_lock;
static pthread_mutex_t pro_lock;
void* consumer(void * _val)
{
    while (1)
    {
        sem_wait(&sem_consume);
        // 保证对conindex的操作加锁就行
        pthread_mutex_lock(&con_lock);
        int c = conindex;
        conindex = (conindex + 1) % _SEM_PRO_;
        pthread_mutex_unlock(&con_lock);
        int _consume = bank[c];
        bank[c] = -5;
        printf("%s ----consume done..., val is : %d\n",(char*)_val, _consume);
        sem_post(&sem_product);// 增加生产者的信号量
        sleep(rand()%5);
    }
}
void* producter(void *_val)
{
    while (1)
    {
         sem_wait(&sem_product);
        // 保证对proindex的操作是加锁的
        pthread_mutex_lock(&pro_lock);
        int p = proindex;
        proindex = (proindex + 1)% _SEM_PRO_;
        pthread_mutex_unlock(&pro_lock);
        int _product = rand() % 100;
        bank[p] = _product;
        printf("%s ---product done..., val is : %d\n",(char*)_val,_product);
        sem_post(&sem_consume);// 增加消费者的信号量
        sleep(rand()%2);
    }
}
void destroy_all_sem()
{
    printf("\nprocess done ...\n");
    sem_destroy(&sem_product);
    sem_destroy(&sem_consume);
    exit(155);
}
void init_all_sem()
{
    signal(2, destroy_all_sem);
    int i = 0;
    for (; i < _SEM_PRO_; i++)
    {
        bank[i] = 0;
    }
    sem_init(&sem_product, 0, _SEM_PRO_);
    sem_init(&sem_consume, 0 , _SEM_COM_);
}
void run_product_consume()
{
    pthread_t tid_consumer1;
    pthread_t tid_producter1;
    pthread_t tid_consumer2;
    pthread_t tid_producter2;
    pthread_create(&tid_consumer1, NULL, consumer, "c1");
    pthread_create(&tid_consumer2, NULL, consumer, "c2");
    pthread_create(&tid_producter1, NULL, producter, "p1");
    pthread_create(&tid_producter2, NULL, producter, "p2");
    //pthread_exit((void *)2);
    pthread_join(tid_consumer1, NULL);
    pthread_join(tid_producter1, NULL);
    pthread_join(tid_consumer2, NULL);
    pthread_join(tid_producter2, NULL);
}
int main()
{
    pthread_mutex_init(&con_lock, NULL);
    pthread_mutex_init(&pro_lock, NULL);
    init_all_sem();
    run_product_consume();
    destroy_all_sem();
    pthread_mutex_destroy(&con_lock);
    pthread_mutex_destroy(&pro_lock);
    return 0;
}

运行：

[bozi@localhost test_20160730]$ make
gcc -o Semaphore_multi Semaphore_multi.c -lpthread
[bozi@localhost test_20160730]$ ./Semaphore_multi
p1 ---product done..., val is : 83
p1 ---product done..., val is : 77
p2 ---product done..., val is : 93
c2 ----consume done..., val is : 83
c1 ----consume done..., val is : 77
p1 ---product done..., val is : 49
p2 ---product done..., val is : 62
c2 ----consume done..., val is : 93
c2 ----consume done..., val is : 49
c1 ----consume done..., val is : 62
p1 ---product done..., val is : 26
p1 ---product done..., val is : 26
p1 ---product done..., val is : 36
p2 ---product done..., val is : 68
p1 ---product done..., val is : 29
c1 ----consume done..., val is : 26
c1 ----consume done..., val is : 26
p1 ---product done..., val is : 23
p2 ---product done..., val is : 35
c2 ----consume done..., val is : 36
p1 ---product done..., val is : 22
^C
process done ...

读写者关系：

读者-读者（共享即没关系）

读者-写者（同步）

写者-写者（互斥）

在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比

较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查

找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没

有一种方法，可以专门处理这种多读少写的情况呢？

有，那就是读写锁。

读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只

对共享资源进行读访问，写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言，

能提高并发性，因为在多处理器系统中，它允许同时有多个读者来访问共享资源，最大可

能的读者数为实际的逻辑 CPU数。写者是排他性的，一个读写锁同时只能有一个写者或多

个读者（与 CPU数相关），但不能同时既有读者又有写者。

通常, 当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞.

读写锁适合于对数据结构的读次数比写次数多得多的情况. 因为, 读模式锁定时可以共享, 以写模式锁住时意味着独占, 所以读写锁又叫共享-独占锁.

用到的函数：

 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
       int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
       int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

练习代码：

#include<stdio.h>
#include <pthread.h>
#define _READER_NUM_ 3
#define _WRITER_NUM_ 2
pthread_rwlock_t lock;
int buf = 0;
void *read(void* _val)
{
    pthread_detach(pthread_self());
    while (1)
    {
        if (pthread_rwlock_tryrdlock(&lock) != 0)
        {
            printf("writer is writing, reader waiting...\n");
        }
        else
        {
            printf("reader is : %u, read val is : %d,\n", pthread_self(), buf);
            pthread_rwlock_unlock(&lock);
        }
        sleep(2);
    }
}
void * write(void* _val)
{
    pthread_detach(pthread_self());
    while (1)
    {
        if (pthread_rwlock_trywrlock(&lock) != 0)
        {
            printf("reader is reading, writer waiting...\n");
            sleep(1);
        }
        else
        {
            buf++;
            printf("writer is %u : write val is : %d\n", pthread_self(), buf);
            pthread_rwlock_unlock(&lock);
        }
        sleep(1);
    }
}
int main()
{
    pthread_rwlock_init(&lock, NULL);
    pthread_t id;
    int i;
    for (i = 0; i < _WRITER_NUM_; i++)
    {
        pthread_create(&id, NULL, write , NULL);
    }
    for (i = 0; i < _READER_NUM_; i++)
    {
        pthread_create(&id, NULL, read, NULL);
    }
    sleep(100);
    return 0;
}

运行：

[bozi@localhost test_20160730]$ gcc -o reader_writer reader_writer.c -pthread
[bozi@localhost test_20160730]$ ./reader_writer
reader is : 3046312816, read val is : 0,
reader is : 3035822960, read val is : 0,
reader is : 3056802672, read val is : 0,
writer is 3067292528 : write val is : 1
writer is 3077782384 : write val is : 2
writer is 3067292528 : write val is : 3
writer is 3077782384 : write val is : 4
reader is : 3046312816, read val is : 4,
reader is : 3035822960, read val is : 4,
reader is : 3056802672, read val is : 4,
writer is 3067292528 : write val is : 5
writer is 3077782384 : write val is : 6
writer is 3067292528 : write val is : 7
writer is 3077782384 : write val is : 8
reader is : 3046312816, read val is : 8,
reader is : 3035822960, read val is : 8,
reader is : 3056802672, read val is : 8,
writer is 3067292528 : write val is : 9
writer is 3077782384 : write val is : 10

1、什么是死锁

如果一组进程中，每一个进程否在等待仅由改组进程中的其他进程才能引发的事件，那么改组进程是死锁的。

2、死锁的产生条件

4个必要条件：

1）互斥条件：一段时间内，某资源只能被一个进程占用。

2）请求和保持条件：进程自己手里已经占有资源，还想申请别的资源，因别的资源申请不到而阻塞，但还不释放自己手上的资源。

3）不可抢占条件：进程已经获得的资源在没有使用完之前不能被抢占，只能在进程使用完时自己释放。

4）循环等待条件：p0等p1的资源，p1等p2的资源，...pn等p0的资源，形成一个进程-资源循环链

3、如何避免死锁

方法一：事先采取某种限制措施，如破环产生死锁的必要条件

因为互斥条件是非共享设备所必须的，不仅不能改变，还应加以保护，因此，主要是破坏产生死锁的后三个条件。

1）破坏“2请求和保持条件”：方法一：进程必须一次性申请完自己运行时所需要的所有资源，即要么全申请，要么一个也不申请。

方法二：允许一个进程只获得运行初期所需要的资源，运行中再释放已经用完的全部资源，然后申请新的资源。这比方法一好，

可以减少进程发生饥饿的几率。

2）破坏“3不可抢占条件”条件：进程申请不到新的资源，必须先把自己已经获得的资源释放，换句话说就是自己手里已经有的资源被抢占了这样就破坏了不可

抢占条件。

3）破坏“4循环等待”条件：对资源编号，进程每次申请多个资源时，由低到高申请，如果需要多个同类资源必须一起申请，如果申请序号低的资源，必须释

放手上比这个信号高或者相等的资源后，才能申请序号低的资源。

方法二：

在资源分配过程中，防止系统进入不安全状态。系统分配资源之前，先计算一下分配好系统是否还安全，然后再决定此次进程的请求是否可行。

著名算法：银行家算法

互斥锁完成互斥

条件变量完成同步

本文出自 “城市猎人” 博客，请务必保留此出处http://alick.blog.51cto.com/10786574/1832251

alick97

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux 线程

进程：资源分配的基本单位线程：进程调度的基本单元线程强调资源共享但不是一味的共享线程两个比较重要的私有成员：【1】必须有自己的硬件上下文进行自己切换时上下文的切换【2】私有栈结构进程强调资源独占但不是一味的共享各线程共享一下进程资源：（1）文件描述符表（2）每种信号的处理方式(SIG_IGN,SIG_DFL或者自定义的信号处理函数)（3）当前工作目录（4）用户i
复制链接

扫一扫

专栏目录