多线程例程

最新推荐文章于 2022-03-16 16:45:33 发布
最新推荐文章于 2022-03-16 16:45:33 发布
阅读量217 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011356503/article/details/105459802
版权

1.子线程 循环打印10次，主线程循环打印100次，接着子线程循环10次，如此循环50次，请写出代码

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


#define LOOPNUM 50
#define MAINLOOPNUM 100
#define CHILDLOOPNUM 10

int num = 0;
int param_0 = 0;
int param_1 = 1;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* threadFunc(void * arg)
{
    for (int i = 0; i < LOOPNUM; i++)
    {
        pthread_mutex_lock(&mutex);

        while (num != param_0)
        {
            pthread_cond_wait(&cond, &mutex);
        }

        printf("child:\n");
        for (int i = 0; i < CHILDLOOPNUM; i++)
        {
            printf("%d", i);
        }
        printf("\n");

        num = (num + 1) % 2;
        
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);
    }
    
    return (void *)0;
}

int main(int argc, char **argv)
{
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    void *ret = NULL;
    pthread_t tid_child;

    pthread_create(&tid_child, NULL, threadFunc, NULL);

    for (int i = 0; i < LOOPNUM; i++)
    {
        pthread_mutex_lock(&mutex);

        while (num != param_1)
        {
            pthread_cond_wait(&cond, &mutex);
        }
        
        printf("main:\n");
        for (int i = 0; i < MAINLOOPNUM; i++)
        {
             printf("%d", i); 
        }
        printf("\n");
        
        num = (num + 1) % 2;
        
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);
    }

    pthread_join(tid_child, &ret);
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;

}

2.创建三个线程A，B，C，轮流打印ABC10次

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

#define LOOPNUM 10
#define THREAD_NUM 3

int num = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* threadFunc(void * arg)
{
	int val = *(int *)arg;
	for (int i = 0; i < LOOPNUM; i++)
	{
		pthread_mutex_lock(&mutex);
		
		while (num != val)
		{
			pthread_cond_wait(&cond, &mutex);
		}
		
		printf("%c", 'A' + val);
		
		num = (num + 1) % THREAD_NUM;
		
		pthread_mutex_unlock(&mutex);
		pthread_cond_broadcast(&cond);
	}
	
	return (void *)0;
}

int main(int argc, char **argv)
{
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);
	void *ret = NULL;
	pthread_t tid[THREAD_NUM];
	int tidNum[3] = {0, 1, 2};
	for (int i = 0; i < THREAD_NUM; i++)
	{
		pthread_create(&tid[i], NULL, threadFunc, (void *)(tidNum + i));	
	}

	for (int i = 0; i < THREAD_NUM; i++)
	{
		pthread_join(tid[i], &ret);
	}
	
	printf("\n");
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	
	return 0;
	
}

3.多个生产者单个消费者，环形共享缓冲区问题。（基于内存信号量）

该问题中需要维持的三个条件为：

(1)缓冲区为空时，消费者不能从中获取条目（移除一个条目）

(2)缓冲区满时，生产者不能往缓冲区中放入一个条目

(3)共享变量描述的当前缓冲区的状态（下标，计数，数据指针等），都必须保护起来。

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

#define BUFFERSIZE 10
#define MAX_THREADS 100

int nItems;
int nProducers;

typedef struct{
	int buff[BUFFERSIZE];
	int nput;
	int nputval;
	sem_t mutex;
	sem_t emptySlot;
	sem_t storeSlot;	
}T_Shared;

T_Shared g_shared;

void* producer(void *arg);
void* consumer(void *arg);

int main(int argc, char **argv)
{
	int count[MAX_THREADS];
	pthread_t tid_producer[MAX_THREADS], tid_consumer;
	
	nItems = atoi(argv[1]);
	nProducers = std::min(atoi(argv[2]), MAX_THREADS);
	
	sem_init(&g_shared.mutex, 0, 1);
	sem_init(&g_shared.emptySlot, 0, BUFFERSIZE);
	sem_init(&g_shared.storeSlot, 0, 0);
						  
	for (int i = 0; i < nProducers; i++)
	{
		count[i] = 0;
		pthread_create(&tid_producer[i], NULL, producer, &count[i]);
	}
						 
	pthread_create(&tid_consumer, NULL, consumer, NULL);
						  
	for (int i = 0; i < nProducers; i++)
    {
		pthread_join(tid_producer[i], NULL);
		printf("count[%d] = %d\n", i, count[i]);
    }
    pthread_join(tid_consumer, NULL);
			
	sem_destroy(&g_shared.mutex);
	sem_destroy(&g_shared.emptySlot);
	sem_destroy(&g_shared.storeSlot);
						  
	return 0;
}
						  
void* producer(void * arg)
{
	for (; ;)
	{
		sem_wait(&g_shared.emptySlot);
		sem_wait(&g_shared.mutex);
		
		if (g_shared.nput >= nItems)
		{
			sem_post(&g_shared.emptySlot);
			sem_post(&g_shared.mutex);
			return NULL;
		}
		g_shared.buff[g_shared.nput % BUFFERSIZE] = g_shared.nputval;
		g_shared.nput++;
		g_shared.nputval++;
		
		sem_post(&g_shared.mutex);
		sem_post(&g_shared.storeSlot);
		*((int *)arg) += 1;
	}
	return (void *)0;
}
						  
void* consumer(void *arg)
{
	for (int i = 0; i < nItems; i++)
	{
		sem_wait(&g_shared.storeSlot);
		sem_wait(&g_shared.mutex);
		
		if (g_shared.buff[i % BUFFERSIZE] != i)
		{
			printf("error:buff[%d] = %d\n", i, g_shared.buff[i % BUFFERSIZE]);	
		}
		
		sem_post(&g_shared.mutex);
		sem_post(&g_shared.emptySlot);	
	}
	
	return (void *)0;
}

4.多个生产者多个消费者，环形共享缓冲区问题。（基于内存信号量）

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <algorithm>
#include <unistd.h>
 
#define BUFFERSIZE 10
#define MAX_THREADS 100
 
int nItems;
int nProducers, nConsumers;
 
typedef struct{
	int buff[BUFFERSIZE];
	int nput;
	int nputval;
    int nget;
    int ngetval;
	sem_t mutex;
	sem_t emptySlot;
	sem_t storeSlot;	
}T_Shared;
 
T_Shared g_shared;
 
void* producer(void *arg);
void* consumer(void *arg);
 
int main(int argc, char **argv)
{
	int countP[MAX_THREADS], countC[MAX_THREADS];
	pthread_t tid_producer[MAX_THREADS], tid_consumer[MAX_THREADS];
	
	nItems = atoi(argv[1]);
	nProducers = std::min(atoi(argv[2]), MAX_THREADS);
    nConsumers = std::min(atoi(argv[3]), MAX_THREADS);
	
	sem_init(&g_shared.mutex, 0, 1);
	sem_init(&g_shared.emptySlot, 0, BUFFERSIZE);
	sem_init(&g_shared.storeSlot, 0, 0);
						  
	for (int i = 0; i < nProducers; i++)
	{
		countP[i] = 0;
		pthread_create(&tid_producer[i], NULL, producer, &countP[i]);
	}

    for (int i = 0; i < nConsumers; i++)
    {
        countC[i] = 0;
        pthread_create(&tid_consumer[i], NULL, consumer, &countC[i]);
    }
						  
	for (int i = 0; i < nProducers; i++)
    {
		pthread_join(tid_producer[i], NULL);
		printf("countP[%d] = %d\n", i, countP[i]);
    }

    for (int i = 0; i < nConsumers; i++)
    {
        pthread_join(tid_consumer[i], NULL);
        printf("countC[%d] = %d\n", i, countC[i]);
    }
			
	sem_destroy(&g_shared.mutex);
	sem_destroy(&g_shared.emptySlot);
	sem_destroy(&g_shared.storeSlot);
						  
	return 0;
}
						  
void* producer(void * arg)
{
	for (; ;)
	{
		sem_wait(&g_shared.emptySlot);
		sem_wait(&g_shared.mutex);
		
		if (g_shared.nput >= nItems)
		{
            sem_post(&g_shared.storeSlot);
			sem_post(&g_shared.emptySlot);
			sem_post(&g_shared.mutex);
			return NULL;
		}
		g_shared.buff[g_shared.nput % BUFFERSIZE] = g_shared.nputval;
		g_shared.nput++;
		g_shared.nputval++;
		
		sem_post(&g_shared.mutex);
		sem_post(&g_shared.storeSlot);
		*((int *)arg) += 1;
	}
	return (void *)0;
}
						  
void* consumer(void *arg)
{
    int i = 0;
	for (; ;)
	{
        sem_wait(&g_shared.storeSlot);
        sem_wait(&g_shared.mutex);

        if (g_shared.nget >= nItems)
        {
            sem_post(&g_shared.storeSlot);
            sem_post(&g_shared.mutex);
            return NULL;
        }

        i = g_shared.nget % BUFFERSIZE;
        if (g_shared.buff[i] != g_shared.ngetval)
        {
            printf("error:buff[%d] = %d\n", i, g_shared.buff[i]);	
        }

        g_shared.nget++;
        g_shared.ngetval++;
        sem_post(&g_shared.mutex);
        sem_post(&g_shared.emptySlot);	
        *((int *)arg) += 1;
	}
	
	return (void *)0;
}

 

496148326
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程控制
weixin_44395170的博客
11-05 143
学习进程创建, 等待, 终止. 使用代码实现. 编写自主shell. 封装fork/wait等操作, 编写函数 process_create(pid_t* pid, void* func, void* arg), func回调函数就是子进程执行的入口函数, arg是传递给func回调函数的参数. 调研popen/system, 理解这两个函数和fork的区别. ...
linux下C++线程的使用
qq_44771537的博客
02-25 2636
一、 创建线程 在Linux下，采用pthread_create函数来创建一个新的线程 语法： #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); thread：指向线程标识符的地址。 attr：用于设置线程属性，一般为null，表示使
线程的创建及运行
welcome to 浩·C's blog
05-30 291
#include #include #include void* thread_main(void*); int main() { pthread_t t_id; int thread_param=5; if(pthread_create(&t_id,NULL,thread_main,&thread_param)!=0) { puts("pthread_create() e
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
小杰312的博客
03-16 5360
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
Linux多线程编程
长期更新Java自学笔记
01-06 2038
线程同步： 多线程环境中，无论调度顺序怎么样，都能得到我们想要的结果 同步的方法： 信号量、互斥锁、条件变量、读写锁 互斥锁只能用于互斥型场景，它的作用等同于二值（0/1）信号量的作用 pthread_create：创建并启动线程 pthread_exit：退出线程 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <pthre
C#控制台多线程例程
11-15
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理...这里提供简单的多线程例程便于移植。
易语言多线程例程
07-24
易语言多线程例程源码,多线程例程,子程序1
DELPHI多线程例程
03-01
通过一个扫描某IP字段中所有电脑名的例程，简单演示如何用DELPHI编写多线程的程序
易语言-易语言服务器组件多线程例程
06-26
易语言服务器组件多线程例程
多线程使用原因以及例程
08-01
关于多线程技术的精华总结，从创建到具体如何应用以及使用多线程的原因及其价值，适合初学者快速理解这部分内容以及开发具体的程序。
多线程简单例子
可视化和机器学习
03-10 585
#include #include #include #include void acceptThread(void *) { for(int j = 0 ;j < 4 ;j ++) { Sleep(100); printf("this is the second thread !\n"); } } int main() {
多线程编程
mangguoni的专栏
06-16 315
简单的多线程编程 　　Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查
多线程使用信号量sem_init,sem_wait,sem_post
qyz_og的博客
08-01 8652
信号量的主要函数有：int sem_init(sem_t *sem,int pshared,unsigned int value); int sem_wait(sem_t *sem); int sem_post(sem_t *sem);sem_init用于对指定信号初始化，pshared为0，表示信号在当前进程的多个线程之间共享，value表示初始化信号的值。 sem_wait可以用来阻塞当前线程
java多线程的常见例子
wenzhi的博客
09-13 6万+
本文有比较常见的java多线程问题的解决方法。对部分知识也有总结。
多线程经典实例(一)
babylove_BaLe的博客
07-20 5423
在多线程的学习当中，有许多经典的例子值得学习，比如售票窗口、线程交替执行、生产者消费者等。下面就来看两个有关线程交替执行的案例。 两个线程轮流打印数字 这里采用 wait/notify 等待通知和 Lock/Condition 两种方式实现。 wait()/notify()实现 简单介绍一下wait/notify机制的几个方法。 以下4个方法都必须在获取了锁的情况下才能调用： ...
java多线程编程实例
热门推荐
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
Linux线程优先级及属性小结
夏天Alex
11-15 7869
介绍同一进程中的多个线程如何保持数据的私有性 Linux内核的几种调度策略：     1.SCHED_OTHER  分时调度策略     2.SCHED_FIFO      实时调度策略，先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃     3.SCHED_RR        实时调度策略，时间片轮转。当进程的时间片用完，系统将重新分配时间片，并置于就绪...
qt 如何用QThread实现多线程例程
最新发布
05-03
在Qt中使用QThread实现多线程例程可以按照以下步骤： 1. 创建一个继承自QThread的自定义线程类，例如MyThread。 2. 在MyThread类中重写run()函数，该函数是线程的执行体，将在新线程中运行。 3. 在run()函数中编写需要在新线程中执行的代码。 4. 在主线程中创建MyThread对象，并调用start()函数启动线程。 下面是一个简单的示例代码，演示了如何使用QThread实现一个简单的多线程例程： ```c++ #include <QThread> #include <QDebug> class MyThread : public QThread { public: void run() override { for (int i = 0; i < 10; i++) { qDebug() << "Thread ID: " << QThread::currentThreadId() << ", " << i; sleep(1); } } }; int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); MyThread thread; thread.start(); for (int i = 0; i < 10; i++) { qDebug() << "Main Thread ID: " << QThread::currentThreadId() << ", " << i; sleep(1); } return a.exec(); } ``` 在上面的代码中，我们创建了一个继承自QThread的自定义线程类MyThread，并在其中重写了run()函数，该函数中包含了需要在新线程中执行的代码。在主函数中，我们创建了MyThread对象，并调用它的start()函数启动线程。同时，在主线程中也包含了需要在主线程中执行的代码。 当程序运行时，我们会看到两个线程交替执行，输出线程ID和计数器的值，证明了多线程例程的成功实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值