C 多线程编程

最新推荐文章于 2023-10-02 09:30:00 发布
最新推荐文章于 2023-10-02 09:30:00 发布
阅读量699 收藏 2
点赞数 1
文章标签： 多线程 java 并发编程 c++ 操作系统
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_35505543/article/details/122663660
版权
6361642989056_.pic.jpg

操作线程的函数

  • 线程的创建
#include <pthread.h>
int pthread_create(
    pthread_t *thread, 
    const pthread_attr_t *attr, 
    void *(*start_routine) (void *), 
    void *arg
);
参数说明
thread输出参数，由 pthread_create 在线程创建成功后返回的线程句柄，该句柄在后续操作线程的 API 中用于标志该新建的线程；
start_routine输入参数，新建线程的入口函数；
arg输入参数，传递给新线程入口函数的参数；
attr输入参数，指定新建线程的属性，如线程栈大小等；如果值为 NULL，表示使用系统默认属性。
  • 线程ID
include <pthread.h>
pthread_t pthread_self(void);
  • 判断两个给定的线程ID是否相等
include <pthread.h>
int pthread_equal(
    pthread_t t1, 
    pthread_t t2
);
参数说明
t1线程ID t1
t2线程ID t2
  • 线程的终止
include <pthread.h>
void pthread_exit(void *retval);
参数说明
retval输出参数，等待的线程终止时的返回值
  • 线程的连接
include <pthread.h>
int pthread_join(
    pthread_t thread,
    void **retval
);
参数说明
thread输入参数，指定希望等待的线程
retval输出参数，等待的线程终止时的返回值，就是在线程入口函数中 return 的值或者调用 pthread_exit 函数的参数
  • 线程的分离
#include <pthread.h>
int pthread_detach(pthread_t thread);
参数说明
thread输入参数，指定希望执行分离操作的线程

线程的属性

  • 属性的初始化与销毁
#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
  • 获取指定线程的属性
#define _GNU_SOURCE
#include <pthread.h>
int pthread_getattr_np(
    pthread_t thread,
    pthread_attr_t *attr
);
  • 设置和获取线程的分离状态
#include <pthread.h>
int pthread_attr_setdetachstate(
    pthread_attr_t *attr,
    int detachstate
);
int pthread_attr_getdetachstate(
    pthread_attr_t *attr,
    int *detachstate
);
  • 设置和获取线程栈地址及大小
#include <pthread.h>
int pthread_attr_setstack(
    pthread_attr_t *attr,
    void *stackaddr,
    size_t stacksize
);
int pthread_attr_getstack(
    pthread_attr_t *attr,
    void **stackaddr,
    size_t *stacksize
);

线程的一次性初始化及特有数据

场景：我们同时创建了N个线程，无法知道哪个线程会被先执行。我们期望这N个线程中谁先运行谁就要去负责去调用一个全局的初始化函数做相关的初始化动作，而该初始化函数仅能被调用一次。

  • 一次性初始化线程
#include <pthread.h>
int pthread_once(
    pthread_once_t *once_control,
    void (*init)(void)
);
参数说明
once_control输入参数，指针，指向通过以下方式初始化的全局变量 pthread_once_t once_var = PTHREAD_ONCE_INIT;
init输入参数，函数指针，执行仅能被执行一次的初始化函数
  • 线程特有数据
#include <pthread.h>
int pthread_key_create(
    pthread_key_t *key,
    void (*destructor)(void *)
);
int pthread_setspecific(
    pthread_key_t key,
    const void *value
);
void *pthread_getspecific(pthread_key_t key);
参数说明
pthread_key_create创建一个全局唯一的 key，用于表示一个数据概念
pthread_setspecific用于线程给某个数据概念分配内存
pthread_getspecific用于线程针对某个数据概念获取其对应的内存(每个线程获取的内存是不一样的)，如果函数返回 NULL 值说明线程还未对该数据概念分配内存
  • 创建 mystrerror.c，代码如下：
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>

#代码思路
#先用 pthread_key_create 创建一个全局的 key，用于表示一块全局的数据概念。
#每个线程在使用该数据概念时，先通过 pthread_getspecific 查询该线程是否为该数据概念分配了内存
#如果线程未对该数据概念分配内存，使用 pthread_setspecific 为该数据概念分配特有内存
#如果线程已对该数据概念分配内存，直接操作该内存

static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_key_t strerrorKey;

#define handle_error_en(en, msg) \
        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
#define handle_error(msg) \
        do { perror(msg); exit(EXIT_FAILURE); } while (0)

#define MAX_ERROR_LEN 256

/*线程特有数据的析构函数*/
static void destructor(void *buf)
{
    free(buf);
}


static void createKey(void)
{
    int s;
    /*在phtread_once函数里创建特有数据的key，
    哪个线程先调用就哪个线程创建key*/
    s = pthread_key_create(&strerrorKey, destructor);
    if (s != 0)
        handle_error_en(s, "pthread_key_create");
}

char *mystrerror(int err)
{
    int s;
    char *buf;

    /*一次性初始化函数*/
    s = pthread_once(&once, createKey);
    if (s != 0)
        handle_error_en(s, "pthread_once");

    /*获取线程特有数据*/
    buf = pthread_getspecific(strerrorKey);
    if (buf == NULL) { /*第一次获取为NULL, 线程需要分配内存*/
        buf = malloc(MAX_ERROR_LEN);
        if (buf == NULL)
            handle_error("malloc");
        /*设置特有数据内存*/
        s = pthread_setspecific(strerrorKey, buf);
        if (s != 0)
            handle_error_en(s, "pthread_setspecific");
    }

    if (err < 0 || err >= _sys_nerr || _sys_errlist[err] == NULL) {
        snprintf(buf, MAX_ERROR_LEN, "Unknown error %d", err);
    } else {
        strncpy(buf, _sys_errlist[err], MAX_ERROR_LEN - 1);
        buf[MAX_ERROR_LEN - 1] = '\0'; /* Ensure null termination */
    }

    return buf;
}

线程的取消

场景：一个线程可以对另一个线程提出取消申请，即线程被动终止的一种情况。

#include <pthread.h>
int pthread_cancel(pthread_t thread);
  • 创建 thread_cancel_sample.c，代码如下：
/*
* file name:thread_cancel_sample.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>

#define handle_error_en(en, msg) \
        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

static void *thread_routine(void *arg)
{
    int j;

    printf("New thread started\n"); /*这里有可能是一个线程取消点 */
    for (j = 1; ; j++) {
        printf("Loop %d\n", j); /*这里也可能是一个线程取消点*/
        sleep(1); /*这里是一个线程取消点*/
    }
    /* 线程执行流程无法到达此处 */
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t thr;
    int s;
    void *res;
    /*创建新线程*/
    s = pthread_create(&thr, NULL, thread_routine, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    /*让新线程飞一会儿*/
    sleep(3);

    /*取消新建线程*/
    s = pthread_cancel(thr);
    if (s != 0)
        handle_error_en(s, "pthread_cancel");
    /*等待新线程退出*/
    s = pthread_join(thr, &res);
    if (s != 0)
        handle_error_en(s, "pthread_join");
    /*判断新线程终止是否是响应取消请求而终止的*/
    if (res == PTHREAD_CANCELED)
        printf("Thread was canceled\n");
    else
        printf("Thread was not canceled (should not happen!)\n");

    return 0;
}

线程互斥

场景：当有多个线程并发的在临界区执行时，程序的执行结果会出现不确定性，这种情况称之为竞态条件。多线程编程中，避免出现竞态条件的一项重要解决方案就是，保证多个线程在临界区是互斥的。所谓的互斥，就是指不能同时有多于一个线程进入临界区。保证临界区互斥的重要技术，就是互斥锁。

  • 互斥锁
# 静态初始化一个全局的互斥锁
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

# 动态分配一个互斥锁
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

# 释放动态分配的互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

# 持有互斥锁
int pthread_mutex_lock(pthread_mutex_t *mutex);

# 释放互斥锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 创建 thread_sync_sample.c，代码如下：
/*
* file name: thread_sync_sample.c
*/

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>

#define handle_error_en(en, msg) \
        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
/*glob为多线程共享资源*/
static int glob = 0;
/* 静态初始化一个全局的互斥锁 */
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;


/*子线程访问修改共享资源glob*/
static void *thread_routine(void *arg)
{
  int loc, j;
  for (j = 0; j < 10000000; j++) {
    /*进入临界区前，先持有互斥锁*/
    pthread_mutex_lock(&mtx);
    loc = glob;
    loc++;
    glob = loc;
    /*退出临界区后，释放互斥锁*/
    pthread_mutex_unlock(&mtx);
  }
  return NULL;
}

int main(int argc, char *argv[])
{
  pthread_t t1, t2;
  int s;

  /*创建两个线程并发访问修改共享资源glob*/
  s = pthread_create(&t1, NULL, thread_routine, NULL);
  if (s != 0)
      handle_error_en(s, "pthread_create");
  s = pthread_create(&t2, NULL, thread_routine, NULL);
  if (s != 0)
      handle_error_en(s, "pthread_create");

  /*等待子线程退出*/
  s = pthread_join(t1, NULL);
  if (s != 0)
      handle_error_en(s, "pthread_join");
  s = pthread_join(t2, NULL);
  if (s != 0)
      handle_error_en(s, "pthread_join");
  /*输出结果*/
  printf("glob = %d\n", glob);
  exit(EXIT_SUCCESS);
}

线程同步

场景：我们有一个共享内存数据资源 M，我们整个程序设计需求是要求线程 A 在 M 上做了处理之后，线程 B 才能做处理。这种需要确保多线程间执行先后顺序的技术，称为线程的同步。条件变量是线程同步的主要手段。其大致的实现思想就是：线程 B，调用条件变量的接口让自身阻塞；线程 A，在处理完资源后，通过条件变量接口唤醒正在等待该资源的线程 B。

  • 条件变量
# 静态初始化：与互斥锁类似静态初始化一个全局的条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

# 动态初始化：
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

# 等待一个指定的条件变量
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

# 唤醒一个等待该条件变量的线程
int pthread_cond_signal(pthread_cond_t *cond);

# 唤醒所有等待该条件变量的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
  • 创建 pthread_cond_sample.c，代码如下：
#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>


pthread_t threads[2];
char writer_char[2] = {'A', 'B'};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;


struct file_res{
    pthread_t *writer; /*当前文件可以被哪个线程写入*/
    int fd; /*文件描述符*/
}file_res =
{
    .writer=&threads[0],/*file初始化可以被线程1写入'A'*/
};

/*线程1和线程2的入口函数*/
void *writer_routine(void *arg)
{
    int index = (intptr_t)arg;
    int i = 0;
    int next_index=0;
    printf("thread %d is running, and will write '%c' to file\n", index, writer_char[index]);

    while(1)
    {
        if (0!=pthread_mutex_lock(&mutex))
            exit(-1);
        for(;;) {

            /*如果当前线程可写file, 执行写操作*/
            if (&threads[index]==file_res.writer) {
                write(file_res.fd, &writer_char[index],
                      sizeof(writer_char[index]));

                /*更新下一个可写线程*/
                next_index = (index+1)%2;
                file_res.writer = &threads[next_index];

                /*执行写操作后，break for循环通过条件变量通知其他线程写*/
                break;
            }

            /*当前线程不可写，等待其他线程唤醒*/
            pthread_cond_wait(&cond,&mutex);
        }

        if (0!=pthread_mutex_unlock(&mutex))
            exit(-1);

        /*唤醒下一个线程*/
        pthread_cond_signal(&cond);

    }
}

int main(int argc, char* argv[])
{

    /*创建空文件file*/
    char file_name[] = "file";
    if ((file_res.fd = open(file_name, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
    {
        printf("open %s error.\n", file_name);
        exit(-1);
    }

    /*创建线程1和线程2*/
    int i;
    for (i=0; i<(sizeof(threads)/sizeof(pthread_t)); i++)
    {
        if(pthread_create(&threads[i], NULL, writer_routine, (void *)(intptr_t)i))
        {
            printf("create writer thread error\n");
            exit(-1);
        }
    }

    /*主线程退出*/
    pthread_exit(NULL);
}
Yohann丶blog
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程编程（C语言版）
qq_31716541的博客
05-10 1110
多线程编程C语言版
c语言多进程多线程编程
07-21
C语言作为一门底层且强大的编程语言，提供了丰富的系统调用接口来实现多进程和多线程编程。 **多进程（Multiprocessing）** 1. **进程定义**：进程是程序的一次执行实例，每个进程都有自己的独立内存空间，包括...
C语言中的多线程编程如何实现？
最新发布
weixin_68551689的博客
10-02 958
线程是一个程序内部的执行单元，每个线程都有自己的执行路径和上下文。一个进程可以包含多个线程，这些线程可以并发执行，共享进程的内存空间和资源，但拥有各自的栈空间和寄存器状态。多线程编程是C语言中的重要编程技术，它允许程序同时执行多个任务，提高了程序的并发性和性能。通过了解线程的创建、退出、传参和返回值，以及线程同步与通信的机制，你可以编写多线程程序来解决各。
C语言多线程
微小冷的学习笔记
03-19 8832
在C语言中创建线程方式如下 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 其中，thread为线程指针；attr为线程属性，默认NULL；start_routine为线程运行函数起始地址；arg为运行函数的参数。无参数时使用NULL。 如果线程成功创建，函数返回0，否则说明创建失败。 当线程完成工作后，若无需继续存在，则会调用pthread_exit函数。也就是说，这个函数可以显式地退出一个线程。
c语言tips-【linux-C语言多线程编程】
留下虚度光阴的一些证据。
01-13 1113
操作系统具有管理进程进程调度的能力，线程，决定哪个进程、线程使用 CPU。很多时候我们需要在同一时间干不同的任务，这就需要我们通过多进程或者多线程来进行，在我们学习和工作中我们大部分用到的都是多线程,本文主要是在linux下探索c语言的多进程的使用方法
C语言多线程基础入门
xuzhougeng blog
03-25 8436
多线程的优势 线程创建更加快速 线程间切换更加快速 线程容易终止 线程间通讯更快速 C语言的多线程可以通过gcc编译器中的pthread实现。 案例1: hello world #include <stdio.h> #include <pthread.h> void *myfunc(void *args){ printf("hello worl...
c语言多线程编程使用示例
09-04
C语言多线程编程使用示例 C语言多线程编程是一种高效的编程方式，允许程序同时执行多个任务，从而提高程序的执行效率和响应速度。在本资源中，我们将介绍C语言多线程编程的使用示例，帮助读者快速掌握多线程编程的...
C语言多线程编程实例.pdf
09-30
C语言多线程编程实例.pdf
linux下C语言多线程编程实例.docx
11-01
在Linux环境下进行C语言多线程编程，可以利用POSIX线程库pthread，它提供了创建、同步和管理线程的功能。以下将详细讲解本实例中涉及的多线程编程概念和关键技术。 首先，多线程是指在一个进程中创建多个执行线程，...
C语言——多线程
Leechee的博客
02-27 2852
不会打目录 先挂链接： https://www.cnblogs.com/xiehongfeng100/p/4620852.html "进程——资源分配的最小单位，线程——程序执行的最小单位" 1. 线程概述 父进程创建子进程会复制一份空间，类似于代码段->数据段->栈->堆-> 参数。 一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。　　 　　进程是程序执行时的一个实例，是担当分配系统资源（CP
c++多线程编程的十个例子
08-21
C++多线程的十个例子，学习window下多线程编程
C语言实现多线程
墨城烟柳ベ旧人殇的博客
04-15 5217
本文主要是学习C语言实现多线程的笔记。
Linux原子操作与锁实现
Lion_Long的博客
09-18 1216
对临界资源操作时，常用原子操作和锁。锁有互斥锁、自旋锁、读写锁等，其他应用程序实现的业务锁如悲观锁、乐观锁等。在两种情况下容易陷入死锁：（1）线程调用两次lock，第一次已经获得锁，第二次发现锁已占用进入等待，而锁是被自己占用，进入无线等待的死锁。（2）多个线程多个锁的情况，线程1获得锁1然后请求锁2，线程2获得锁2然后请求锁1，互相等待，进入锁。原子操作就是通过一条指令解决问题，封装的CAS将多条执行命令变为一条执行命令，使其不可分割。
c语言多线程实例
reg183的专栏
11-17 1395
#include "stdafx.h" #include<windows.h> #include <stdio.h> HANDLE hFile; //定义临界区 CRITICAL_SECTION cs; DWORD WINAPI Thread(LPVOID lpParam) { //得到线程的编号 int n = (int)lpParam; DWORD dvWrite; for (int i = 0; i < 10000; i++){ //进入临界区 En..
C/C++宏定义中的do{...} while(0)
weixin_41632560的博客
12-05 228
C/C++宏定义中的do{...} while(0) 2016年08月25日 11:25:44 D1ngo 阅读数：500 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/limo120621/article/details/52312947 注：带颜色的文本是转发者自己添加的 C/C++宏定义中do{…} while(0)的用途 今天在...
【linux】把进程/线程绑定到特定cpu核上运行
bandaoyu的note
02-05 1万+
目的 某个进程需要较高的运行效率时，就有必要考虑将其绑定到单独的核上运行，以减小由于在不同的核上调度造成的开销。 把某个进程/线程绑定到特定的cpu核上后，该进程就会一直在此核上运行，不会再被操作系统调度到其他核上。但绑定的这个核还是可能会被调度运行其他应用程序的。 命令绑定 查看绑定情况 查看进程pid现在的绑核情况 taskset -p pid pid 2726's current affinity mask: 6 显示的十进制数字6--->转换为2进制是110，每个1对应一个cp
C语言多线程编程
技无涯的博客
11-27 903
C语言多线程编程 介绍：什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-l...
linux下的C语言开发（多线程编程）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
02-06 3万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     多线程和多进程还是有很多区别的。其中之一就是，多进程是linux内核本身所支持的，而多线程则需要相应的动态库进行支持。对于进程而言，数据之间都是相互隔离的，而多线程则不同，不同的线程除了堆栈空间之外所有的数据都是共享的。说了这么多，我们还是自己编写一个多线程程序看看结果究竟是怎么
c语言多线程编程
05-31
C语言中，多线程编程可以使用pthread库来实现。使用pthread库需要包含头文件pthread.h。 下面是一个简单的多线程程序示例： ``` #include #include void *start_routine(void *arg) { printf("Hello from ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值