C语言多线程编程学习记录1

由于工作中用到了多线程编程，所以需要快速入门。

学习教程来自于博客：cnblogs.com/zzdbullet/p/9526130.html

介绍：什么是线程，线程的优点是什么

线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。

线程可以提高应用程序在多核环境下处理诸如文件I/O或者socket I/O等会产生堵塞的情况的表现性能。在Unix系统中，一个进程包含很多东西，包括可执行程序以及一大堆的诸如文件描述符地址空间等资源。在很多情况下，完成相关任务的不同代码间需要交换数据。如果采用多进程的方式，那么通信就需要在用户空间和内核空间进行频繁的切换，开销很大。但是如果使用多线程的方式，因为可以使用共享的全局变量，所以线程间的通信（数据交换）变得非常高效。

 

Hello World(线程创建、结束、等待）

创建线程 pthread_create

线程创建函数包含四个变量，分别为：

1. 一个线程变量名，被创建线程的标识

2. 线程的属性指针，缺省为NULL即可

3. 被创建线程的程序代码

4. 程序代码的参数 For example： - pthread_t thrd1; - pthread_attr_t attr; - void thread_function(void argument); - char *some_argument;

pthread_create(&thrd1, NULL, (void *)&thread_function, (void *) &some_argument);

结束线程 pthread_exit

线程结束调用实例：pthread_exit(void *retval); //retval用于存放线程结束的退出状态

线程等待 pthread_join

pthread_create调用成功以后，新线程和老线程谁先执行，谁后执行用户是不知道的，这一块取决与操作系统对线程的调度，如果我们需要等待指定线程结束，需要使用pthread_join函数，这个函数实际上类似与多进程编程中的waitpid。 举个例子，以下假设 A 线程调用 pthread_join 试图去操作B线程，该函数将A线程阻塞，直到B线程退出，当B线程退出以后，A线程会收集B线程的返回码。 该函数包含两个参数：

• pthread_t th //th是要等待结束的线程的标识
• void **thread_return //指针thread_return指向的位置存放的是终止线程的返回状态。

调用实例：pthread_join(thrd1, NULL);

也就是说，创建一个线程可以分为如下几步：

1、首先得有个名字啊——定义一个线程的描述符name，类似于文件描述符fd。

pthread_t name;

2、这个线程，得需要有活儿干啊——线程从哪儿开始执行dosomething

pthread_create(&name, NULL, (void *)&dosomething, (void *) &dosomething_args);

3、总得知道线程啥时候干完活儿啊——pthread_join,干完活儿后，干的结果咋样？——retval——我是监工，线程干活儿时我就等着

pthread_join(name, &retval);

4、我不想干等着，那就直接啥时候干完了告诉我就行——pthread_exit

pthread_exit(void *retval)

上面这几步，基本可以满足一个入门需求——最起码知道基本的流程

既然是多线程了，那么就共享了进程的资源，如果要对一个变量进行访问，总得有个先来后到吧！

于是出现了锁和信号量——都是对资源进行保护或者记录，要不然就乱套了

锁

1、首先得定义一个锁吧——有这几种方式，在不同的阶段定义了锁

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

• 在主线程中初始化锁为解锁状态
  • pthread_mutex_t mutex;
  • pthread_mutex_init(&mutex, NULL);
• 在编译时初始化锁为解锁状态
  • 锁初始化 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
• 访问对象时的加锁操作与解锁操作
  • 加锁 pthread_mutex_lock(&mutex)
  • 释放锁 pthread_mutex_unlock(&mutex)

2、这个锁咋用啊——

判断锁是不是开的，如果是，就先锁上——这个时候别的线程就别想用了

    /*加锁*/
        if (pthread_mutex_lock(&mutex) != 0) {
           perror("pthread_mutex_lock");
           exit(EXIT_FAILURE);
        }

访问变量或者其它操作

开锁，用完了就赶紧打开，别的线程还等着呢

    /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

信号量

锁有一个很明显的缺点，那就是它只有两种状态：锁定与不锁定。

信号量本质上是一个非负数的整数计数器，它也被用来控制对公共资源的访问。当公共资源增加的时候，调用信号量增加函数sem_post()对其进行增加，当公共资源减少的时候，调用函数sem_wait()来减少信号量。其实，我们是可以把锁当作一个0-1信号量的。

它们是在/usr/include/semaphore.h中进行定义的，信号量的数据结构为sem_t, 本质上，它是一个long型整数

相关函数

在使用semaphore之前，我们需要先引入头文件#include <semaphore.h>

• 初始化信号量： int sem_init(sem_t *sem, int pshared, unsigned int value);
  • 成功返回0，失败返回-1
  • 参数
  • sem：指向信号量结构的一个指针
  • pshared： 不是0的时候，该信号量在进程间共享，否则只能为当前进程的所有线程们共享
  • value：信号量的初始值
• 信号量减1操作，当sem=0的时候该函数会堵塞 int sem_wait(sem_t *sem);
  • 成功返回0，失败返回-1
  • 参数
  • sem：指向信号量的一个指针
• 信号量加1操作 int sem_post(sem_t *sem);
  • 参数与返回同上
• 销毁信号量 int sem_destroy(sem_t *sem);
  • 参数与返回同上

也就是说，这个信号量就是，用的时候，标记一下，用完之后，再标记一下，别的线程自己去判断什么时候用，什么时候不用

比如，当发现没有信号的时候——sem==0，则新城就阻塞在这儿。

/*************************************************************************
    > File Name: sem.c
    > Author: couldtt(fyby)
    > Mail: fuyunbiyi@gmail.com 
    > Created Time: 2013年12月15日 星期日 19时25分08秒
 ************************************************************************/

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

#define MAXSIZE 10

int stack[MAXSIZE] = {0};
int size = 0;
sem_t sem;

// 生产者
void provide_data(void) {
    int i;
    for (i=0; i< MAXSIZE; i++) {
        sleep(1);
        stack[i] = i;
        sem_post(&sem); //为信号量加1
    }
}

// 消费者
void handle_data(void) {
    int i;
    while((i = size++) < MAXSIZE) {
        sem_wait(&sem);
        printf("乘法: %d X %d = %d\n", stack[i], stack[i], stack[i]*stack[i]);
        
    }
}

int main(void) {

    pthread_t provider, handler;

    sem_init(&sem, 0, 0); //信号量初始化
    pthread_create(&provider, NULL, (void *)handle_data, NULL);
    pthread_create(&handler, NULL, (void *)provide_data, NULL);
    pthread_join(provider, NULL);
    pthread_join(handler, NULL);
    sem_destroy(&sem); //销毁信号量

    return 0;
}

上面的代码中，就避免了打印时，用到未初始化的值引起的错误。

注：信号量的代码在实验时，可以在provide_data函数中加入休眠函数，来测试是否信号量会起作用，结果表明，如果不使用信号量，则均为初始值0，如果使用信号量，则和预期相符，为乘法表。

 

也就是说关键在于sem_wait()函数，这个是线程间同步的关键！