精华内容
下载资源
问答
  • C语言面试常见问题总结---线程通信的三种方法
    千次阅读
    2020-09-13 23:03:05

    多线程通信的方法主要有以下三种: 

    1.全局变量

    进程中的线程间内存共享,这是比较常用的通信方式和交互方式。

    注:定义全局变量时最好使用volatile来定义,以防编译器对此变量进行优化。

    Linux系统中的线程间通信方式主要以下几种:

    *  锁机制:包括互斥锁、条件变量、读写锁和自旋锁。

     互斥锁确保同一时间只能有一个线程访问共享资源。当锁被占用时试图对其加锁的线程都进入阻塞状态(释放CPU资源使其由运行状态进入等待状态)。当锁释放时哪个等待线程能获得该锁取决于内核的调度。

      读写锁当以写模式加锁而处于写状态时任何试图加锁的线程(不论是读或写)都阻塞,当以读状态模式加锁而处于读状态时“读”线程不阻塞,“写”线程阻塞。读模式共享,写模式互斥。

       条件变量可以以原子的方式阻塞进程,直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

       自旋锁上锁受阻时线程不阻塞而是在循环中轮询查看能否获得该锁,没有线程的切换因而没有切换开销,不过对CPU的霸占会导致CPU资源的浪费。 所以自旋锁适用于并行结构(多个处理器)或者适用于锁被持有时间短而不希望在线程切换产生开销的情况。

    2.Message消息机制

    常用的Message通信的接口主要有两个:PostMessage和PostThreadMessage,

    PostMessage为线程向主窗口发送消息。而PostThreadMessage是任意两个线程之间的通信接口。

    3.CEvent对象

    CEvent为MFC中的一个对象,可以通过对CEvent的触发状态进行改变,从而实现线程间的通信和同步。

    更多相关内容
  • 线程通信及同步方法介绍

    千次阅读 2021-05-23 11:01:04
    线程间通信及同步方法介绍:一、线程间的通信方式1、使用全局变量主要由于多个线程可能更改全局变量,因此全局变量最好声明为volatile。2、使用消息实现通信在Windows程序设计中,每一个线程都可以拥有自己的消息...

    线程间如何通信/同步?此前小编给大家介绍了进程间通信的方法,于是一些伙伴又好奇线程间的通信及同步方法,没关系,下面小编就继续给大家科普下线程间通信及同步的方法。

    174a3dc2b1617613f6275146a1660f5d.png

    线程间通信及同步方法介绍:

    一、线程间的通信方式

    1、使用全局变量

    主要由于多个线程可能更改全局变量,因此全局变量最好声明为volatile。

    2、使用消息实现通信

    在Windows程序设计中,每一个线程都可以拥有自己的消息队列(UI线程默认自带消息队列和消息循环,工作线程需要手动实现消息循环),因此可以采用消息进行线程间通信sendMessage,postMessage。

    1)定义消息#define WM_THREAD_SENDMSG=WM_USER+20;

    2)添加消息函数声明afx_msg int OnTSendmsg();

    3)添加消息映射ON_MESSAGE(WM_THREAD_SENDMSG,OnTSM);

    4)添加OnTSM()的实现函数;

    5)在线程函数中添加PostMessage消息Post函数。

    3、使用事件CEvent类实现线程间通信

    Event对象有两种状态:有信号和无信号,线程可以监视处于有信号状态的事件,以便在适当的时候执行对事件的操作。

    1)创建一个CEvent类的对象:CEvent threadStart;它默认处在未通信状态;

    2)threadStart.SetEvent();使其处于通信状态;

    3)调用WaitForSingleObject()来监视CEvent对象。

    二、线程间的同步方式

    各个线程可以访问进程中的公共变量,资源,所以使用多线程的过程中需要注意的问题是如何防止两个或两个以上的线程同时访问同一个数据,以免破坏数据的完整性。

    数据之间的相互制约包括:

    1、直接制约关系,即一个线程的处理结果,为另一个线程的输入,因此线程之间直接制约着,这种关系可以称之为同步关系。

    2、间接制约关系,即两个线程需要访问同一资源,该资源在同一时刻只能被一个线程访问,这种关系称之为线程间对资源的互斥访问,某种意义上说互斥是一种制约关系更小的同步。

    线程间的同步方式有四种:

    1、临界区

    临界区对应着一个CcriticalSection对象,当线程需要访问保护数据时,调用EnterCriticalSection函数;当对保护数据的操作完成之后,调用LeaveCriticalSection函数释放对临界区对象的拥有权,以使另一个线程可以夺取临界区对象并访问受保护的数据。

    PS:关键段对象会记录拥有该对象的线程句柄即其具有“线程所有权”概念,即进入代码段的线程在leave之前,可以重复进入关键代码区域。所以关键段可以用于线程间的互斥,但不可以用于同步(同步需要在一个线程进入,在另一个线程leave)。

    2、互斥量

    互斥与临界区很相似,但是使用时相对复杂一些(互斥量为内核对象),不仅可以在同一应用程序的线程间实现同步,还可以在不同的进程间实现同步,从而实现资源的安全共享。

    PS:

    1)互斥量由于也有线程所有权的概念,故也只能进行线程间的资源互斥访问,不能由于线程同步;

    2)由于互斥量是内核对象,因此其可以进行进程间通信,同时还具有一个很好的特性,就是在进程间通信时完美的解决了“遗弃”问题。

    3、信号量

    信号量的用法和互斥的用法很相似,不同的是它可以同一时刻允许多个线程访问同一个资源,PV操作。

    PS:事件可以完美解决线程间的同步问题,同时信号量也属于内核对象,可用于进程间的通信。

    4、事件

    事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数(所有内核对象都有),一个布尔值表示是手动置位事件还是自动置位事件,另一个布尔值用来表示事件有无触发。由SetEvent()来触发,由ResetEvent()来设成未触发。

    PS:事件是内核对象,可以解决线程间同步问题,因此也能解决互斥问题。

    关于线程间的通信及同步方法就给大家讲解到这里了,更多关于线程同步的文章,大家可以参考:《线程同步的方法有哪些?Linux下实现线程同步的三种方法》

    展开全文
  • 基于C语言线程通信消息队列实现

    千次阅读 2019-01-09 22:46:20
    在多线程编程中经常需要进行线程线程间的通信,由于线程间能够共享数据结构,也就是一个全局变量能够被两个线程同时候使用。但是要注意的是线程的同步和互斥。 线程同步是指线程之间所具有的一种制约关系,一个...

             在多线程编程中经常需要进行线程与线程间的通信,由于线程间能够共享数据结构,也就是一个全局变量能够被两个线程同时候使用。但是要注意的是线程的同步互斥
             线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒。
             线程互斥是指当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其它要使用该资源的线程必须等待,直到占用资源者释放该资源。一般采用互斥锁来解决互斥的问题,但是使用时一定要注意避免死锁。

             在接收回调数据的时候,不能进行太过耗时的处理,通常将数据拷贝至消息队列,在其他线程进行处理。如下为项目总结的消息队列和使用示例:

    msg_process.c

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <sys/time.h>
    #include "msg_process.h"
     
    static unsigned long long timeout_ns = 0;
    
    #define LOG_ERR(fmt, ...) do{\
    	printf("[ERROR]  "fmt"  [line:%d] [%s]\n", ##__VA_ARGS__, __LINE__, __FUNCTION__);\
    }while(0);
     
    #define LOG_WARN(fmt, ...) do{\
    	printf("[WARNING]  "fmt"  [line:%d] [%s]\n", ##__VA_ARGS__, __LINE__, __FUNCTION__);\
    }while(0); 
     
    /**
     * 消息处理模块内部接口
     */
    static void put_msg_to_buffer(tmsg_buffer* buf, tmsg_element* elm){
    	if (NULL == buf || NULL == elm) {
    		LOG_ERR("buf or elm is NULL");
    		return;
    	}
     
    	if (NULL != elm->next) {
    		elm->next = NULL;
    	}
     
    	pthread_mutex_lock(&buf->mutex);
    	//缓冲区尚无消息节点
    	if (buf->first == buf->last
    			&& 0 == buf->num) {
    		buf->first = elm;
    		buf->last = elm;
    		buf->num ++;
    		//TODO:通知等待消息而阻塞的线程
    		pthread_cond_signal(&buf->not_empty);
    	} else {
    		//将新的消息节点信息添加到缓冲区的尾部
    		buf->last->next = elm;
    		buf->last = elm;
    		buf->num ++;
    	}
     
    	pthread_mutex_unlock(&buf->mutex);
    }
     
     
    static tmsg_element* get_msg_from_buffer(tmsg_buffer* buf, int block){
    	tmsg_element *elm = NULL;
     
    	if (NULL == buf) {
    		LOG_ERR("buf is NULL");
    		return NULL;
    	}
     
    	pthread_mutex_lock(&buf->mutex);
    	//缓冲区中无消息节点
    	while (0 == buf->num) {
    		//阻塞线程等待消息节点
    		pthread_cond_wait(&buf->not_empty, &buf->mutex);
    	}
    	//从缓冲区首部取出消息节点
    	elm = buf->first;
    	if (1 == buf->num) {
    		buf->first = buf->last = NULL;
    		buf->num = 0;
    	} else {
    		buf->first = buf->first->next;
    		buf->num --;
    	}
     
    	pthread_mutex_unlock(&buf->mutex);
     
    	return elm;
    }
     
     
     
    static tmsg_element* get_msg_from_buffer_timeout(tmsg_buffer* buf, int block/*ms*/){
    	tmsg_element *elm = NULL;
    //	struct timeval timenow;
    	struct timespec timeout;
     
    	if (NULL == buf) {
    		LOG_ERR("buf is NULL");
    		return NULL;
    	}
     
    	pthread_mutex_lock(&buf->mutex);
    	//缓冲区中无消息节点
    	if (0 == buf->num) {
    #if 1
    		clock_gettime(CLOCK_MONOTONIC, &timeout);
    		timeout.tv_sec = timeout.tv_sec + block/1000; //加上秒数
    		block %= 1000;	//得到毫秒数
    
    		timeout_ns = timeout.tv_nsec + block*1000*1000;
    		if( timeout_ns >= 1000*1000*1000 ) //若超过1s
    		{
    			timeout.tv_sec ++;
    			timeout.tv_nsec = timeout_ns - 1000*1000*1000;
    		}
    		else
    			timeout.tv_nsec = timeout_ns;
    #else	//解决系统时间改变导致消息队列阻塞的bug
    		gettimeofday(&timenow,NULL);
    		timeout.tv_sec = timenow.tv_sec + block/1000; //加上秒数
    		block %= 1000;	//得到毫秒数
    
    		timeout_ns = timenow.tv_usec*1000 + block*1000*1000;
    		if( timeout_ns >= 1000*1000*1000 ) //若超过1s
    		{
    			timeout.tv_sec ++;
    			timeout.tv_nsec = timeout_ns - 1000*1000*1000;
    		}
    		else
    			timeout.tv_nsec = timeout_ns;
    #endif
    		//带超时时间阻塞线程等待消息节点
    		pthread_cond_timedwait(&buf->not_empty, &buf->mutex, &timeout);
    	}
     
    	if (buf->num > 0) {
    		//从缓冲区首部取出消息节点
    		elm = buf->first;
    		if (1 == buf->num) {
    			buf->first = buf->last = NULL;
    			buf->num = 0;
    		} else {
    			buf->first = buf->first->next;
    			buf->num --;
    		}
    	}
     
    	pthread_mutex_unlock(&buf->mutex);
     
    	return elm;
    }
     
     
    static tmsg_element* clear_msg_buffer(tmsg_buffer* buf){
    	tmsg_element* elm = NULL;
    	tmsg_element* elm_tmp = NULL;
     
    	if (NULL == buf){
    		LOG_ERR("buf is NULL");
    		return NULL;
    	}
     
    	//清空buffer中当前消息节点之前的所有消息节点
    	pthread_mutex_lock(&buf->mutex);
    	if (buf->num > 0) {
    		elm = buf->first;
    		while(elm != NULL) {
    			//首尾指针指向同一消息节点
    			if (elm == buf->last) {
    				buf->first = buf->last;
    				if (buf->num != 1) {
    					buf->num = 1;
    				}
    				break;
    			}
     
    			elm_tmp = elm->next;
    			free_tmsg_element(elm);
    			buf->num --;
    			elm = elm_tmp;
    			buf->first = elm;
    		}
    	}
     
    	pthread_mutex_unlock(&buf->mutex);
     
    	return elm;
    }
     
     
    static void send_msg_to_buffer(tmsg_buffer* buf, int msg, int ext, char* str, int len)
    {
    	tmsg_element *elm = NULL;
     
    	elm = (tmsg_element *)malloc(sizeof(tmsg_element));
    	if (NULL == elm) {
    		LOG_ERR("new msg element failed!!");
    		return;
    	}
     
    	if(len > TMSG_MAX_LEN) //限制最大申请长度
    	{
    		len = TMSG_MAX_LEN;
    		LOG_WARN("Data is truncated,which must less than %d!",TMSG_MAX_LEN);
    	}
    	//填充消息节点数据
    	memset(elm, 0, sizeof(tmsg_element));
    	elm->msg = msg;
    	elm->ext = ext;
    	elm->dt = NULL;
    	elm->sub0 = 0;
    	elm->sub1 = 0;
    	elm->dt_len = len;
    	if (str) 
    	{
    		elm->dt = (char *)malloc(len);  //根据发送的大小申请内存
    		if(elm->dt == NULL)
    		{
    			LOG_ERR("new element->dt failed!!");
    			free_tmsg_element(elm);
    			return;
    		}	
    		else
    			memmove(elm->dt, str, len);
    	}
    	
    	elm->next = NULL;
    	//将消息节点添加到缓冲区中
    	put_msg_to_buffer(buf, elm);
    }
     
     
    static void send_msg_to_buffer_ex(tmsg_buffer* buf, int msg, int ext, int sub0, int sub1, char* str, int len){
    	tmsg_element *elm = NULL;
     
    	elm = (tmsg_element *)malloc(sizeof(tmsg_element));
    	if (NULL == elm) {
    		LOG_ERR("new msg element failed!!");
    		return;
    	}
    	
    	if(len > TMSG_MAX_LEN) //限制最大申请长度
    	{
    		len = TMSG_MAX_LEN;
    		LOG_WARN("Data is truncated,which must less than %d!",TMSG_MAX_LEN);
    	}
    	
    	//填充消息节点数据
    	memset(elm, 0, sizeof(tmsg_element));
    	elm->msg = msg;
    	elm->ext = ext;
    	elm->sub0 = sub0;
    	elm->sub1 = sub1;
    	elm->dt = NULL;
    	elm->dt_len = len;
    	if (str) 
    	{
    		elm->dt = (char *)malloc(len);  //根据发送的大小申请内存
    		if(elm->dt == NULL)
    		{
    			LOG_ERR("new element->dt failed!!");
    			free_tmsg_element(elm);
    			return;
    		}	
    		else
    			memmove(elm->dt, str, len);
    	}
    	elm->next = NULL;
    	//将消息节点添加到缓冲区中
    	put_msg_to_buffer(buf, elm);
    }
     
     
    static void dispose_msg_buffer(tmsg_buffer* buf){
    	tmsg_element* elm = NULL;
     
    	if (NULL == buf) {
    		return;
    	}
     
    	if (buf->first != buf->last
    			&& buf->num > 0) {
    		elm = clear_msg_buffer(buf);
    	} else {
    		elm = buf->last;
    	}
     
    	if (NULL != elm) {
    		free_tmsg_element(elm);
    		buf->first = buf->last = NULL;
    		buf->num = 0;
    	}
     
    	pthread_mutex_destroy(&buf->mutex);
    	pthread_cond_destroy(&buf->not_empty);
    	free(buf);
     
    	buf = NULL;
    }
     
     
    static int get_msg_num(tmsg_buffer* buf){
    	if (NULL == buf) {
    		return 0;
    	}
     
    	return buf->num;
    }
     
     
    /**
     * 以下为消息处理模块对外接口
     */
     
    /*消息缓冲区初始化*/
    tmsg_buffer* msg_buffer_init(void){
    	tmsg_buffer* msg_buffer = NULL;
    	pthread_condattr_t cattr;
     
    	msg_buffer = (tmsg_buffer *)malloc(sizeof(tmsg_buffer));
    	if (NULL == msg_buffer){
    		LOG_ERR("init msg buffer failed!!");
    		return NULL;
    	}
     
    	//初始化成员变量和函数
    	memset(msg_buffer, 0, sizeof(tmsg_buffer));
    	msg_buffer->first = NULL;
    	msg_buffer->last = NULL;
    	msg_buffer->num = 0;
     
    	pthread_mutex_init(&(msg_buffer->mutex), NULL);
    #if 1
    	pthread_condattr_init(&cattr);
    	pthread_condattr_setclock(&cattr, CLOCK_MONOTONIC);
    	pthread_cond_init(&(msg_buffer->not_empty), &cattr);
    #else
    	pthread_cond_init(&(msg_buffer->not_empty), NULL);
    #endif
     
    	//继续绑定接口
    	msg_buffer->put = put_msg_to_buffer;
    	msg_buffer->get = get_msg_from_buffer;
    	msg_buffer->get_timeout = get_msg_from_buffer_timeout;
    	msg_buffer->clear = clear_msg_buffer;
    	msg_buffer->sendmsg = send_msg_to_buffer;
    	msg_buffer->sendmsgex = send_msg_to_buffer_ex;
    	msg_buffer->dispose = dispose_msg_buffer;
    	msg_buffer->getnum = get_msg_num;
     
    	return msg_buffer;
    }
     
     
    /*复制消息节点*/
    tmsg_element* dup_msg_element(tmsg_element* elm){
    	tmsg_element* msg_element = NULL;
    	if (NULL == elm) {
    		LOG_ERR("msg element is NULL!!");
    		return NULL;
    	}
     
    	msg_element = (tmsg_element *)malloc(sizeof(tmsg_element));
    	if (NULL == msg_element) {
    		LOG_ERR("create msg element is failed!!");
    		return NULL;
    	}
     
    	memcpy(msg_element, elm, sizeof(tmsg_element));
     
    	return msg_element;
    }
     
    void free_tmsg_element(tmsg_element *msg_element)
    {
    	if(msg_element != NULL)
    	{
    		if(msg_element->dt != NULL)
    		{
    			free(msg_element->dt);
    			msg_element->dt = NULL;
    		}
    		free(msg_element);
    		msg_element = NULL;
    	}
    }
     
    

    msg_process.h

    #ifndef _MSG_PROCESS_H_
    #define _MSG_PROCESS_H_
    #include <pthread.h>
    
    
    #define TMSG_MAX_LEN 4096 //最大限制为4K
    
    typedef struct msg_element tmsg_element;
     
    struct msg_element
    {
        tmsg_element* next;
        int msg;
        int ext;
        int sub0;
        int sub1;
    	int dt_len;
        char *dt;
    };
      
    typedef struct msg_buffer tmsg_buffer;
    
    struct msg_buffer
    {
        tmsg_element* first;
        tmsg_element* last;
        int             num;
     
        pthread_mutex_t mutex;
        pthread_cond_t  not_empty;
     
        void (*put)(tmsg_buffer* buf, tmsg_element* elm);
        tmsg_element* (*get)(tmsg_buffer* buf, int block);
        tmsg_element* (*get_timeout)(tmsg_buffer* buf, int block);
     
        tmsg_element* (*clear)(tmsg_buffer* buf);
        void (*sendmsg)(tmsg_buffer* buf, int msg, int ext, char* str, int len);
        void (*sendmsgex)(tmsg_buffer* buf, int msg, int ext, int sub0, int sub1, char* str, int len);
        void (*dispose)(tmsg_buffer* buf);
     
        int (*getnum)(tmsg_buffer* buf) ;
    };
     
     
     
    /*消息缓冲区初始化*/
    tmsg_buffer* msg_buffer_init(void);
     
     
    /*复制消息节点*/
    tmsg_element* dup_msg_element(tmsg_element* elm);
     
    /*释放消息节点*/
    void free_tmsg_element(tmsg_element *msg_element);
     
     
    #endif /* MESSAGE_MSG_CENTER_H_ */
    

    example.c  //调用示例

    #include <stdio.h>
    #include <unistd.h>
    #include "msg_process.h"
     
    int main(int argc,char *argv[])
    {
     
    	tmsg_buffer* test_msg_buff = NULL;
    	test_msg_buff = msg_buffer_init();
    	char table[] = "{\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\","
    				   "\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\""
    				   ",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\""
    				   ",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\""
    				   ",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\",\"hello\",\"world\"}";
    	test_msg_buff->sendmsg(test_msg_buff,0,0,table,sizeof(table)); //发送数据
     
    	sleep(2);
     
    	tmsg_element* event = NULL;
    	event = test_msg_buff->get_timeout(test_msg_buff,1000);  //接收数据
    	if(event != NULL)
    	{
    		if(event->dt != NULL)
    		{
    			int i = 0;
    			printf("Recv:");
    			for(i=0; i<event->dt_len; i++)
    			{
    				printf("%c",event->dt[i]);
    			}
    			printf("\n");
    		}
    	}
    	free_tmsg_element(event);
    	
        return 0;
    }

    执行结果

    展开全文
  • C例子:线程通信

    2016-01-24 23:28:05
    该程序是我写的博客“一起talk C栗子吧(第一百一十一回:C语言实例--线程通信)”的配套程序,共享给大家使用
  • C语言中的线程通信

    2021-05-21 03:20:25
    我有两个线程(应用程序主线程和另一个线程).我正在使用OpenGL绘制一些东西,我正在使用OpenGL键盘和鼠标回调.当我调用glutMainLoop()时OpenGL会阻塞,因为我必须在后台进行一些计算,所以我创建了另一个线程.现在,...

    我有两个线程(应用程序主线程和另一个线程).我正在使用OpenGL绘制一些东西,我正在使用OpenGL键盘和鼠标回调.当我调用glutMainLoop()时OpenGL会阻塞,因为我必须在后台进行一些计算,所以我创建了另一个线程.现在,OpenGL回调应将一些数据(例如,已被按下的鼠标/键的x,y位置)发送到具有临界区的另一个线程.当关键部分正在运行时,不应该接受任何消息,但是我想在关键部分之后处理它们,而不是丢弃这些消息.非OpenGL的类看起来像这样:

    void run()

    {

    for (;;) {

    int currentTime = now();

    if (now() - previousTime > WAIT_INTERVAL) {

    previousTime = currentTime;

    tick();

    }

    }

    }

    void tick() {

    // critical section begins

    processor->step()

    // critical section ends

    }

    void receiveMessage(void *data) {

    processor->changeSomeData(data);

    }

    因此,如果从OpenGL线程调用receiveMessage()并且处理器 – > step()正在运行,则应该推迟对changeSomeData()的调用,因为它会弄乱整个计算.

    我想使用以下类来同步线程:

    Mutex.h:

    #ifndef MUTEX_H

    #define MUTEX_H

    #include

    class Mutex;

    #include "Lock.h"

    class Mutex

    {

    public:

    Mutex();

    ~Mutex();

    private:

    void acquire();

    void release();

    CRITICAL_SECTION criticalSection;

    friend class Lock;

    };

    #endif

    Mutex.cpp:

    #include "Mutex.h"

    Mutex::Mutex()

    {

    InitializeCriticalSection(&this->criticalSection);

    }

    Mutex::~Mutex()

    {

    DeleteCriticalSection(&this->criticalSection);

    }

    void Mutex::acquire()

    {

    EnterCriticalSection(&this->criticalSection);

    }

    void Mutex::release()

    {

    LeaveCriticalSection(&this->criticalSection);

    }

    Lock.h:

    #ifndef LOCK_H

    #define LOCK_H

    class Lock;

    #include "Mutex.h"

    class Lock

    {

    public:

    Lock(Mutex& mutex);

    ~Lock();

    private:

    Mutex &mutex;

    };

    #endif

    Lock.cpp

    #include "Lock.h"

    Lock::Lock(Mutex& mutex) : mutex(mutex)

    {

    this->mutex.acquire();

    }

    Lock::~Lock ()

    {

    this->mutex.release();

    }

    编辑:

    编辑2:

    解决方法:

    哦……不,不,不.线程不是你应该在这里使用的.认真.在这种特殊情况下,线程不是您的解决方案.让我们回滚一下……

    你现在正在使用GLUT而且你说你需要线程来“避免锁定glutMainLoop().而你不想要锁定,因为你想在此期间进行一些计算.”

    现在停下来问自己 – 你确定那些操作需要从OpenGL渲染异步(整体)完成吗?如果是这样,你可能会停止阅读这篇文章并查看其他帖子,但我真诚地相信,对于典型的实时OpenGL应用程序而言可能并非如此.

    所以…典型的OpenGL应用程序如下所示:

    >处理事件

    >刻度计算

    >重绘屏幕

    大多数GL窗口库允许你将它实现为你自己的主循环,GLUT类似于用它的“回调”来混淆,但是这个想法是一样的.

    您仍然可以在应用程序中引入并行性,但它应该在步骤2开始和停止,因此它仍然在主循环级别上顺序:“计算一帧计算,然后渲染此帧”.这种方法可能会为您省去很多麻烦.

    Protip:改变您的图书馆. GLUT已经过时,不再维护了.切换到GLFW(或SDL)以创建窗口不会在代码方面花费太多精力 – 与GLUT相反 – 您自己定义主循环,这似乎是您想要在此实现的. (另外,它们往往更便于输入和窗口事件处理等)

    一些具有恒定时间步实时物理特性的典型伪代码,不会干扰渲染(假设您通常比渲染更经常运行物理):

    var accum = 0

    const PHYSICS_TIMESTEP = 20

    while (runMainLoop) {

    var dt = getTimeFromLastFrame

    accum += dt

    while (accum > PHYSICS_TIMESTEP) {

    accum -= PHYSICS_TIMESTEP

    tickPhysicsSimulation(PHYSICS_TIMESTEP)

    }

    tickAnyOtherLogic(dt)

    render()

    }

    可能的扩展是使用accum的值作为附加的“外推”值仅用于渲染,这将允许在视觉上平滑图形表示,同时更少地模拟物理(具有更大的DT),可能比每次渲染更少一次帧.

    标签:glut,c,multithreading,opengl,visual-studio

    来源: https://codeday.me/bug/20190730/1580757.html

    展开全文
  • C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
  • 参考:https://blog.csdn.net/a987073381/article/details/52029070 https://blog.csdn.net/liu5320102/article/details/50764645 ...一、基础知识简介 1、 线程之间通信的...
  • 多进程和多线程是系统执行多任务机制的重要手段,多任务同时进行自然少不了相互之间的通信工作。下面先将线程间的通信方式总结一下,便于大家对比学习。
  • 关于C语言线程同步的方式

    千次阅读 2020-07-31 10:48:49
    C语言线程同步的方式线程同步互斥锁读写锁条件变量信号量 线程同步 在多线程环境中,线程之间由于竞争共享资源(临界资源)容易引起数据不一致的问题。一般采用互斥锁(互斥信号量)解决,保证只有一个线程进入...
  • 这个程序是在window下用c编写的socket基于多线程的程序,程序能够完美运行,并且程序注解也是很清楚的哦!Liunx版本的c编写的socket多线程的聊天室也是有的,程序中有可直接执行的exe文件方便大家测试。
  • Linux C语言线程通信

    千次阅读 2019-12-03 20:53:16
    //启动线程grl(); sleep ( 1 ) ; } return NULL ; } void * grl ( void * arg ) { DATA * data = ( DATA * ) arg ; puts ( "grl start..." ) ; while ( time ( NULL ) - data...
  • 以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区,消费者线程则从中取出产品。缓冲区有N 个,是一个环形的缓冲池。 ...
  • 2014#include #include #include #define THREAD_NUM 10void *test(void *args) {printf("tid %d: i say 'Hello'.\n", args);return NULL;}int main() {int i, err;pthread_t child[THREAD_NUM];...
  • 1.线程中不使用sleep,不会造成线程切换问题。 2.线程中使用sleep,会使cpu的占有率降低。让其他线程或进程,运行得更有效。 3.使用sleep(0)和不使用sleep,效果差别不大,都不会使cpu睡眠。usleep(0)和usleep(1)...
  • 线程通信

    千次阅读 2021-05-23 05:40:41
    线程通信前面一章讲了线程间同步,提到了信号量、互斥量、事件集等概念;本章接着上一章的内容,讲解线程通信。在裸机编程中,经常会使用全局变量进行功能间的通信,如某些功能可能由于一些操作而改变全局变量的...
  • } -----这是服务端程序------ #include "stdio.h" #include "winsock2.h" #include "stdlib.h" #define MAXCLIENTS 2 #pragma comment(lib,"ws2_32") /* 多线程 SOCKET */ DWORD WINAPI ...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼Windows操作系统,C语言实现多线程:#include#includeDWORDAPIENTRYThreadOne(LPVOIDthreadArg){printf("线程开始啦,参数是:%s\n",(char*)threadArg);return0;}intmain...
  • C语言如何终止线程

    2021-05-21 10:27:09
    /* 以生产者和消费者模型问题来阐述linux线程的控制和通信你生产者线程将生产的产品送入缓冲区,消费者线程则从中取出产品。缓冲区有n个,是一个环形的缓冲池。*/#include#include#define buffer_size 16struct ...
  • C语言开启多线程

    2022-03-30 09:39:41
    文章目录文章目录多线程C语言中的多线程创建多线程阻塞和分离等待和退出线程标识和判断独占数据线程对象线程存储共享数据互斥条件互斥原子操作内存栅栏多线程总结 多线程 计算机发展初期为单核单任务,windows开始...
  • 认识C语言线程

    2020-06-14 16:21:42
    文章目录线程背景知识串行计算与并行计算并行计算的内存架构线程模型进程和线程之的区别为什么要多线程POSIX线程(pthread)库线程基础线程创建和终止参考文献 线程背景知识 串行计算与并行计算 传统上,软件是为...
  • C语言线程实现TCP并发服务器

    千次阅读 2022-03-27 22:07:17
    线程数组的大小就是我们的并发服务器能够支持的最高并发量,如果超过了,就让客户端进行等待,直到线程数组出现空闲的子线程 其实我们一直都在创建子线程,但是通过子线程回调函数的参数数组将子线程的数量限制在...
  • 线程同步,互斥锁,条件变量,读写锁
  • 1.单进程通信客户端代码#include #include #include #include #include #include #include #include void usage(const char *str
  • _beginthread和_beginthreadex是Windows下创建线程的函数。 结束线程函数_endthread和_endthreadex。 主线程结束了,子线程也会结束。 _beginthread函数原型 /** \brief 创建一个线程 * * \param start_address ...
  • visual c++利用管道和线程实现进程间通信
  • Linux下C语言线程,网络通信简单聊天程序.pdf
  • Python线程通信方式

    千次阅读 2019-06-04 20:16:30
    1、python多线程 #! /usr/bin/evn python3 # --*-- coding: utf-8 --*-- #该实例反编译来说明函数执行流程 import dis ...# Python中一个线程对应于C语言中的一个线程(CPython而言)(Python并不一定...
  • 本设计通过scoket编程实现tcp中客户端与服务器之间的通信,包含两个文件,一个多进程实现客户端访问,另一个多线程实现客户端访问;代码经过验证可以跑通,并且程序包含有大量的中文注释,适合像博主这样的小白进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,432
精华内容 17,772
关键字:

c语言线程通信方式