线程同步题目

最新推荐文章于 2021-11-23 20:26:09 发布
最新推荐文章于 2021-11-23 20:26:09 发布
阅读量1k 收藏
点赞数
分类专栏： 笔试面试 C/C++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GoOnDrift/article/details/19257979
版权
linux 同时被 3 个专栏收录
48 篇文章 0 订阅
订阅专栏
C/C++
34 篇文章 2 订阅
订阅专栏
笔试面试
5 篇文章 0 订阅
订阅专栏 
题目一：子线程循环5次，接着主线程循环10次， 
接着又回到子线程循环5次，接着再回到主线程又循环10次， 
如此循环6次，试写出代码。 
解法一，mutex
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <pthread.h>

//如果只有一个mutex，在创建了子线程，主线程休眠后，让子线程执行，子线程执行了10次后，休眠。
//过了这个休眠时间，调度线程执行的时候，如果系统任务多，可能仍是子线程在执行的。
pthread_mutex_t  mutex;

//临界区数据
//00表示初始状态
//01表示之前在执行子线程
//10表示之前在执行主线程
int flag1,flag2;

//如果不用条件变量，只用mutex。
//那么子线程和主线程都会不断的获得mutex，然后判断自己是否该执行，如果不该执行，就释放，然后sleep下。
//如果可以执行就执行，然后再sleep。
//这样效率太低。
//pthread_cond_t cond;


void loopChild(){
	printf("child: ");
	for(int i = 1; i <= 5; i++) 
		printf("%d ", i);
	printf("\n");
	
}

void loopParent(){
	printf("Parent: ");
	for(int i = 1; i <= 10; i++ ) 
		printf("%d ", i);
	printf("\n");
	
}

void setParentFlag(){
	flag1 = 1; 
	flag2 = 0;
}

void setChildFlag(){
	flag1 = 0;
	flag2 = 1;
}

//轮到子线程执行
bool isChildTurn(){
	if( 1 == flag1 && 0 == flag2)
		return true;
	return false;
}

//轮到父线程执行
bool isParentTurn(){
	if( 0 == flag1 && 1 == flag2)
		return true;
	return false;
}

void *func(void *arg) {
	while(1){
		pthread_mutex_lock(&mutex);
		if( isChildTurn()){
			//之前在执行主线程
			setChildFlag();
			loopChild();
		}
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
}


int main() {
	
	pthread_mutex_init(&mutex, NULL);
	setParentFlag();
	
	pthread_t pid = pthread_create(&pid, NULL, func, NULL );
	sleep(1);
	
	int cnt = 0;
	while(1) {
		pthread_mutex_lock(&mutex);
		if( isParentTurn() ){
			//之前在执行子线程
			setParentFlag();
			loopParent();
			
			cnt++;
			if(6 == cnt){
				break;
			}
			
		}	
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	
	pthread_cancel(pid);
	pthread_mutex_destroy(&mutex);
	
	exit(0);
}


解法二，使用condition variable 

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <pthread.h>

//如果只有一个mutex，在创建了子线程，主线程休眠后，让子线程执行，子线程执行了10次后，休眠。
//过了这个休眠时间，调度线程执行的时候，如果系统任务多，可能仍是子线程在执行的。
pthread_mutex_t  mutex;

//临界区数据
//00表示初始状态
//01表示之前在执行子线程
//10表示之前在执行主线程
int flag1,flag2;

//如果不用条件变量，只用mutex。
//那么子线程和主线程都会不断的获得mutex，然后判断自己是否该执行，如果不该执行，就释放，然后sleep下。
//如果可以执行就执行，然后再sleep。
//这样效率太低。
pthread_cond_t cond;


void loopChild(){  
    printf("child: ");  
    for(int i = 1; i <= 5; i++)   
        printf("%d ", i);  
    printf("\n");  
      
}  
  
void loopParent(){  
    printf("Parent: ");  
    for(int i = 1; i <= 10; i++ )   
        printf("%d ", i);  
    printf("\n");  
      
}  
  
void setParentFlag(){  
    flag1 = 1;   
    flag2 = 0;  
}  
  
void setChildFlag(){  
    flag1 = 0;  
    flag2 = 1;  
}  
  
//轮到子线程执行  
bool isChildTurn(){  
    if( 1 == flag1 && 0 == flag2 )  
        return true;  
    return false;  
}  

void *func(void *arg) {
	while( 1) {
		pthread_mutex_lock(&mutex);
		if(!isChildTurn()){
			pthread_cond_wait(&cond, &mutex);	
		}
		loopChild();
		setChildFlag();
		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond);
	}
}

int main() {
	
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);
	setParentFlag();
	
	pthread_t pid = pthread_create(&pid, NULL, func, NULL );
	sleep(1);
	
	int cnt = 0;
	while(1) {
		pthread_mutex_lock(&mutex);
		if(isChildTurn()){
			pthread_cond_wait(&cond, &mutex);	
		}
		loopParent();
		setParentFlag();
		cnt++;  
		if(6 == cnt){  
			break;  
		}  
		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond);
	}
	
	pthread_cancel(pid);
	sleep(1);
	
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	exit(0);
}


第二题

/*
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，
每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

pthread_t  pidA, pidB, pidC;

sem_t semA, semB, semC;

void *funcA(void *arg) {
	for(int i = 0; i < 10; i++){
		sem_wait(&semA);
		printf("A"); 
		fflush(stdout);
		sem_post(&semB);
	}
	return NULL;
}

void *funcB(void *arg) {
	for(int i = 0; i < 10; i++){
		sem_wait(&semB);
		printf("B", i);
		fflush(stdout);
		sem_post(&semC);
	}
	return NULL;
}

void *funcC(void *arg) {
	for(int i = 0; i < 10; i++){
		sem_wait(&semC);
		printf("C");
		fflush(stdout);
		sem_post(&semA);
	}
	return NULL;
}


int main( ) {
	sem_init(&semA, 0, 1);
	sem_init(&semB, 0, 0);
	sem_init(&semC, 0, 0);
	
	pthread_create(&pidA, NULL, funcA, NULL );
	pthread_create(&pidB, NULL, funcB, NULL );
	pthread_create(&pidC, NULL, funcC, NULL );
	
	pthread_join(pidA, NULL);
	pthread_join(pidB, NULL);
	pthread_join(pidC, NULL);
	
	sem_destroy(&semA);
	sem_destroy(&semB);
	sem_destroy(&semC);
	
	exit(0);
}


第三题:生产者消费者问题
这是一个非常经典的多线程题目，题目大意如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。

解法一，使用mutex

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

#define NUMS 10  //表示生产，消费的次数  
#define CAPACITY 5 //定义缓冲区最大值  

int capacity = 0; //当前缓冲区的产品个数  

pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;//互斥量  
  
void* produce(void *args)  
{  
    int i = 0;  
    for (; i < NUMS; )  
    {  
        pthread_mutex_lock(&mylock);//加锁  
        if (capacity >= CAPACITY) //当前产品个数大于等于缓冲区最大值，则不把产品放入缓冲区。  
        {  
            printf("Producer : buffer full, can't add item \n");  
        } else {//将产品放入缓冲区  
            ++capacity;  
            printf("Producer : add a item, buff size is :%d\n", capacity);  
            i++;  
        }  
        pthread_mutex_unlock(&mylock);  
    }  
    return ((void *) 0);  
}  
  
void* consume(void *args)  
{  
    int i = 0;  
    for (; i < NUMS; )  
    {  
        pthread_mutex_lock(&mylock);  
        if (capacity > 0)   
        {  
            --capacity;  
            printf("Consumer: consume an item, buff size is :%d\n", capacity);  
            i++;  
        } else {  
           printf("Consumer : buff is empty, can't consume item\n");  
        }  
        pthread_mutex_unlock(&mylock);  
    }  
    return ((void *) 0);  
}  
  
int main(int argc, char** argv) {  
  
    int err;  
    pthread_t produce_tid, consume_tid;  
    void *ret;  
    err = pthread_create(&produce_tid, NULL, produce, NULL);//创建线程  
    if (err != 0)   
    {  
        printf("thread creat failed :%s\n", strerror(err));  
        exit(-1);  
    }  
    err = pthread_create(&consume_tid, NULL, consume, NULL);  
    if (err != 0)  
    {  
        printf("thread creat failed :%s\n", strerror(err));  
        exit(-1);  
    }  
    err = pthread_join(produce_tid, &ret);//主线程等到子线程退出  
    if (err != 0)   
    {  
        printf("producer thread join failed :%s\n", strerror(err));  
        exit(-1);  
    }  
    err = pthread_join(consume_tid, &ret);  
    if (err != 0)  
    {  
        printf("consumer thread join failed :%s\n", strerror(err));  
        exit(-1);  
    }  
	
    return (EXIT_SUCCESS);  
}

结果满足题意。但是这存在一个问题，极端情况下，生产者每次都加锁成功，那缓冲区会满，产品无法放入缓冲区。消费者会被饿死，因为他一直无法获得互斥量。

改进？


（Google面试题）
有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....
D：4 1 2 3 4 1....
请设计程序。



xtf__moji
关注
专栏目录
java线程同步问题例题
m0_48660145的博客
04-29 928
要求： 在main方法中启动两个线程 第一个线程循环随机打印100以内的整数 第二个进程从键盘读取了”Q“命令 package com.yuanhuajun.Homework; import java.util.Scanner; /** * @author Yhj * @date 2022/4/29 8:44 * @project chapter17 */ public class Homework01 { public static void main(String[] a.
线程间同步详解
TABE_的博客
01-10 2765
进程（线程）间同步进程同步和进程间通信的区别进程/线程间同步机制临界区互斥量信号量管程三个经典的进程间同步问题（生产者消费者问题、读者写者问题、哲学家就餐问题）生产者消费者问题读者写者问题哲学家就餐问题 进程同步和进程间通信的区别 进程同步用于控制多个进程按照一定的顺序访问资源。 进程通信用于进程间传输信息，进程同步是一种进程通信的表现形式，通过修改信号量，进程之间可相互协调运行和协同工作。但是信号量与PV操作只能传递信号，没有传递数据的能力，正因如此才有了各种进程间通信机制（IPC）。 进程/线程间同步机
线程同步（练习题）
博客的博客
11-23 211
目录 一、分析： 1.是否是多线程问题？ 2.是否有共享数据 3.有线程安全问题嘛？ 4.需要考虑如何解决线程安全问题？ 二、代码实现 一、分析： 1.是否是多线程问题？ 是，两个储户线程 2.是否有共享数据 有，账户（或账户余额） 3.有线程安全问题嘛？ 有 4.需要考虑如何解决线程安全问题？ 同步机制 --- > 3种方式 二、代码实现 class Account{ private double balance; public...
线程同步练习
树洞树洞-单纯记录
01-12 256
模拟铁路售票系统，实现通过四个售票点发售100张火车票（即同日同次列车）， 一个售票点用一个线程来表示。 package com.gqy; public class Tickets_Excends_Thread extends Thread{ private int tickets = 100; public void run(){ while(true){ ...
Java之线程同步练习
weixin_30797199的博客
05-02 333
1.有一张银行卡：*属性：name，money（账户余额）* 多线程操作同一张银行卡： 金额：x（每次存钱取钱的数额，取钱时x为负数，存钱时x为整数） 定义一个add方法：用于存取钱，参数为x，即每次取或存的金额 add(int x){ 判断x的正负 要么存，要么取 显示余额 } ...
java多线程同步问题
06-19
多线程注意：wait（）方法的调用要有判定条件常用 while () obj.wait(timeout, nanos); ... // Perform action appropriate to condition } synchronized会影响共享数据，但对其他语句的执行不会有规律了！
C#简单多线程同步和优先权用法实例
12-25
本文实例讲述了C#简单多线程同步和优先权用法。分享给大家供大家参考。具体分析如下： 本文实例题目如下： 麦当劳有两个做汉堡的厨师（工号：11，12）和三个销售人员（工号：21，22，23）。 厨师生产汉堡，并负责将...
进程的同步与互斥习题(含部分题目的参考答案).doc
01-03
进程的同步与互斥习题 本文将对进程的同步与互斥习题进行详细的解释和分析，涵盖了多种不同的场景和问题，包括进程的同步、互斥、信号量、缓冲区、生产者消费者问题、读者写者问题、司机与售票员问题、汽车过桥问题...
一道线程的同步题
Sodino的专栏
03-08 1223
Question 123 Click the Exhibit button. Given: 1. public class TwoThreads { 2 3. private static Object resource = new Object(); 4. 5. private static void delay(long n) { 6. try { Thread.sleep(n); } 7.
线程同步面试题深入解析
03-13
用什么关键字修饰同步方法 ? 用synchronized关键字修饰同步方法
多线程同步问题-练习题1-笔记整理
Mark2When的博客
04-30 663
练习题1 现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志， 请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象， 程序只需要运行4秒即可打印完这些日志对象。     解决方案：将主线程中产生的数据存入到阻塞队列中，启动的四个消费者线程一次去队列中取数据。 题目代码示例： /* 现有的程序代码模拟产生了16个日
【Java自用】线程同步-练习题
爱写bug的王六六
09-17 252
题目描述 有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。 分析： 1.是否是多线程问题？ 是，两个储户线程 2.是否有共享数据？ 有，账户（或账户余额） 3.是否有线程安全问题？有 4.需要考虑如何解决线程安全问题？同步机制：有三种方式。 //账户 class Account{ private double balance;//余额 public Account(double balance) {//构造器 this
线程同步的一个练习
白鹭的博客
03-05 350
//avoid negative number
试水多线程-线程同步练习
hxqneuq2012的专栏
08-11 783
首先小结一下释放锁的情况： 当前线程的同步方法、同步代码块执行结束。 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。 同时注意不会释放锁的操作：
线程同步及练习
WDWDWDGJW的博客
11-18 251
使用synchronized修饰的方法控制对类成员变量的访问 访问修饰符synchronized 返回类型 方法名(参数列表）{......} 或者synchronized访问修饰符 返回类型 方法名(参数列表){......} synchronized就是为当前的线程声明一把锁 代码演示如下： * @Description模拟用户网络购票--使用同步方法解决线程带来的数据不安全问题 */ public class TicketThread implements Runnable{ ..
多线程同步问题-练习题3-笔记整理
Mark2When的博客
04-30 607
练习题3： 程序同时启用了4个线程去调用TestDo.doSome()方法，由于TestDo.doSome方法内部的代码是先暂停1秒，   然后在输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：   4:4:1258199615   1:1:1258199615   3:3:1258199615   1:1:1258199615   修改代码，如果有几个线程调用
多线程同步问题-练习题2-笔记整理
Mark2When的博客
04-30 440
练习题2： 主线程中代码不断产生数据，然后交给TestDo.doSome()方法去处理，将程序改成有10个线程来消费生产者产生的数据。   这些消费者都调用Test.doSome()来处理，，每个消费者都需要1秒才能处理完，程序应保证这些消费者线程依次有序的消费数据，   只有上一个消费者消费完后，下一个消费者才能消费数据。，但要保证这些消费者线程拿到的数据是有顺序的     题意情景
线程同步
qq_40734618的博客
09-17 126
线程同步 线程的主要优点是通过全局变量来共享信息，即会带了另一个问题，即同一变量可能被多个线程同时访问修改，为避免此问题，使用互斥量来确保同一时刻只有一个线程来访问资源。 互斥量既可以静态分配，也可动态分配。需要注意的是：在使用中，如果其他线程(或自己本身线程)已经锁定的这一互斥量，调用mutex_lock（）会一直阻塞(或发生死锁)。 同样使用pthread_mutex_unlock()去解锁未锁定的互斥量，或其他线程的互斥量，一样会发生错误。 以下示例代码： #include <pthrea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值