精华内容
下载资源
问答
  • 转自:http://blog.chinaunix.net/uid-25808509-id-3026355.html #include iostream> #include cstdio> #include Windows.h> class TestClass { public:  TestClass()
    1. 转自:http://blog.chinaunix.net/uid-25808509-id-3026355.html



    1. #include <iostream>
    2. #include <cstdio>
    3. #include <Windows.h>

    4. class TestClass
    5. {
    6. public:
    7.     TestClass()
    8.         :x(0)
    9.     {
    10.         ::Sleep(1000);
    11.         num++;
    12.     }
    13.     ~TestClass(){}
    14.     void Inc() { x++;}
    15.     void Show()
    16.     {
    17.         char result[20] ={0};
    18.         sprintf(result, "x = %d\n", x);
    19.         printf(result);
    20.     }

    21. public:
    22.     static int num;

    23. private:
    24.     int x;
    25.     
    26. };

    27. int TestClass::num = 0;

    28. class CLock
    29. {
    30. public:
    31.     CLock()
    32.     {
    33.         ::InitializeCriticalSection(&m_Section);
    34.     }
    35.     ~CLock()
    36.     {
    37.         ::DeleteCriticalSection(&m_Section);
    38.     }

    39.     void Lock()
    40.     {
    41.         ::EnterCriticalSection(&m_Section);
    42.     }

    43.     void UnLock()
    44.     {
    45.         ::LeaveCriticalSection(&m_Section);
    46.     }

    47. private:
    48.     CRITICAL_SECTION m_Section;
    49. };

    50. template <typename T>
    51. class Singleton
    52. {
    53. public:
    54.     static T* getPointer()
    55.     {
    56.         if(m_instance == NULL)
    57.         {
    58.             m_Lock.Lock();

    59.             if(m_instance == NULL)
    60.             {

    61.                 T* instance = new T();

    62.                 m_instance = reinterpret_cast<void*>(instance);
    63.             }

    64.             m_Lock.UnLock();
    65.         }

    66.         return reinterpret_cast<T*>(m_instance);
    67.         
    68.     }

    69.     static T & instance()
    70.     {
    71.         return *getPointer();
    72.     }

    73.     static void release()
    74.     {
    75.         if(m_instance)
    76.         {
    77.             delete m_instance;
    78.             m_instance = NULL;
    79.         }
    80.     }

    81. private:
    82.     static void* m_instance;
    83.     static CLock m_Lock;
    84. };

    85. template<typename T>
    86. void* Singleton<T>::m_instance = 0;

    87. template<typename T>
    88. CLock Singleton<T>::m_Lock;

    89. HANDLE g_hThreads[3] = {0};


    90. DWORD WINAPI func(LPVOID p)
    91. {
    92.     
    93.     int i = 0;
    94.     while(< 5)
    95.     {
    96.         Singleton<TestClass>::instance().Inc();
    97.         Singleton<TestClass>::instance().Show();

    98.         Sleep(1);

    99.         ++i;
    100.     }

    101.     return 1;
    102. }

    103. int main()
    104. {
    105.     for(int i = 0; i < 3; ++i)
    106.     {
    107.         g_hThreads[i] = ::CreateThread(NULL, 0, func, NULL, 0, NULL);
    108.     }

    109.     ::WaitForMultipleObjects(3, g_hThreads, TRUE, INFINITE );

    110.     Singleton<TestClass>::release();

    111.     std::cout << "finished" << std::endl;

    112.     std::cout << "has create " << TestClass::num << " TestClass!" << std::endl;

    113.     system("pause");

    114.     return 0;
    115. }
    程序运行结果
    x = 1
    x = 2
    x = 3
    x = 4
    x = 5
    x = 6
    x = 7
    x = 9
    x = 8
    x = 10
    x = 12
    x = 11
    x = 13
    x = 14
    x = 15
    finished
    has create 1 TestClass!

    -------------------------------------------------------------------------------------------------
    为了解决多线程环境,解决静态对象的删除,采用局部静态对象,得到最优化,最简约的单例模式如下:
    #include <QtCore/QCoreApplication>
    #include <QDebug>

    class Singleton
    {
    private:
        Singleton() 
        {
            qDebug()<<"Contruct Singleton";
        }
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
     public:
        static Singleton * GetInstance()
        {
           static Singleton m_Single;
           return &m_Single;
        }
    };
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        Singleton *tmp = Singleton::GetInstance();
        return a.exec();
    }

    展开全文
  • 自己要修改项目,使window下的项目可以在linux下可以运行得通。对于多线程操作临界资源区域,window下的操作是通过API函数来操作的。 对于linux下操作,则是通过互斥来进行操作的。这和window下的代码是不同的,...


    自己要修改项目,使window下的项目可以在linux下可以运行得通。对于多线程操作临界资源区域,window下的操作是通过API函数来操作的。

    对于linux下操作,则是通过互斥锁来进行操作的。这和window下的代码是不同的,至少不是相似的。不过,步骤倒是相同的。都是初始化,上锁,解锁,摧毁四个步骤来操作的。

    int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

    int pthread_mutex_lock(pthread_mutex_t *mutex);

    int pthread_mutex_unlock(pthread_mutex_t *mutex);

    int pthread_mutex_destroy(pthread_mutex_t *mutex);

    是通过以上想对应的函数来进行操作的。不过低于锁的初始化,有两种形式,动态和静态。大多数是用的静态方式。

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


    展开全文
  • 原子:当多个线程同时对同一资源进行操作时,由于线程间资源的抢占,会导致操作的结果丢失或者不是我们预期的结果。 比如:线程A对一个变量进行var++操作,线程B也执行var++操作,当线程A执行var++时,如果线程切换时间...

    原子锁:当多个线程同时对同一资源进行操作时,由于线程间资源的抢占,会导致操作的结果丢失或者不是我们预期的结果。

    比如:线程A对一个变量进行var++操作,线程B也执行var++操作,当线程A执行var++时,如果线程切换时间恰好是线程A将结果存在var变量之前,那么线程B继续执行var++;此时假设var值已经被线程B更新,这时轮流到线程A执行,线程A会将接着上次停止的点继续向下执行,这时B对var变量的更改将会被覆盖掉;原子锁是对单条操作指令进行原子保护,保证在同一时间,只能有一个线程对变量进行操作,以此确保数据的正确性.

    1、InterlockedIncrement:加1操作; 
    2、InterlockedDecrement:减1操作; 
    3、InterlockedExchangeAdd:加上“指定”的值,可以加上一个负数; 
    4、InterlockedExchange、InterlockedExchangePointer:能够以原子操作的方式用第二个参数的值来取代第一个参数的值;

    一般情况下,在多线程编程中如果对某一个变量的值进行改变的话,使用以上互锁函数确实比较方便,但有很多时候多线程间会操作更为复杂的东西
    比如对一个结构的赋值、对链表的插入与删除 等等,以上互锁函数不能满足要求,所以要使用更为高级的多线程间的同步技术!

    没有使用原子锁的情况:
    #include <Windows.h> 
    #include <iostream> 
    using namespace std;
    
    #define ThreadNum  2 
    #define CIRCLETIME 1000000 
    long g_loginCount = 0; 
    long g_value = 0;
    
    DWORD WINAPI ThreadProc1( __in  LPVOID lpParameter ) 
    { 
        for( int index=0; index<CIRCLETIME; index++ ) 
        { 
            g_loginCount++; 
        } 
        return 0; 
    }
    
    DWORD WINAPI ThreadProc2( __in  LPVOID lpParameter ) 
    { 
        for( int index=0; index<CIRCLETIME; index++ ) 
        { 
            g_loginCount++; 
        } 
        return 0; 
    }
    
    int main() 
    { 
        HANDLE handle[ ThreadNum ] = {0};
    
        handle[0] = CreateThread(NULL,0,ThreadProc1,NULL,0,NULL); 
        handle[1] = CreateThread(NULL,0,ThreadProc2, NULL,0 ,NULL );
    
        WaitForMultipleObjects(ThreadNum,handle,TRUE,INFINITE); 
        CloseHandle( handle[0] ); 
        CloseHandle( handle[1] );
    
        cout << "循环之后的值为: " << g_loginCount  << " " <<  g_value << endl; 
        return 0; 
    }

    运行2次结果如下:
    image

    image

    使用原子锁的情况:

    DWORD WINAPI ThreadProc2( __in  LPVOID lpParameter ) 
    { 
        for( int index=0; index<CIRCLETIME; index++ ) 
        { 
            g_loginCount++; 
            InterlockedIncrement( &g_value  ); 
        } 
        return 0; 
    }
    
    DWORD WINAPI ThreadProc1( __in  LPVOID lpParameter ) 
    { 
        for( int index=0; index<CIRCLETIME; index++ ) 
        { 
            g_loginCount++; 
            InterlockedIncrement( &g_value  ); 
        }         
        return 0; 
    }

     

    运行2次结果如下:

    image
    image

    转载于:https://www.cnblogs.com/staring-hxs/p/3664193.html

    展开全文
  • window下简单的生产者和单一消费的程序 使用window下的事件和临界区实现, 在Linux可以使用条件变量和互斥实现, 简单的代码如下: #ifndef _MSGQUEUE_ #define _MSGQUEUE_ /// //消息队列节点 // #include &...

    window下简单的生产者和单一消费的程序

    使用window下的事件和临界区实现,

    在Linux可以使用条件变量和互斥锁实现,

    简单的代码如下:

    #ifndef _MSGQUEUE_
    #define _MSGQUEUE_
    ///
    //消息队列节点
    //
    #include <Windows.h>
    
    #define MY_X_LOCK(x) EnterCriticalSection(x)
    #define MY_X_UNLOCK(x) LeaveCriticalSection(x)
    #define MY_X_LOCK_INIT(x) InitializeCriticalSection(x)
    #define MY_X_LOCK_DEINIT(x) DeleteCriticalSection(x)
    #define MY_COND_WIAT( XHanle , block_time_ms ) WaitForSingleObject(XHanle , block_time_ms)
    #define MY_COND_CREATE() CreateEvent(NULL,TRUE,FALSE, NULL)
    #define MY_COND_SEND(x) SetEvent(x)
    #define MY_COND_DESTROY(x) CloseHandle(x)
    //
    //使用指针传参
    //
    template <typename Object>
    class MSGQueue {
    public:
    	
    	MSGQueue(int size):theSize(size){ init(); }
    	~MSGQueue(){ clear(); }
    
    	/*
    	*push data to queue
    	*/
    	void push( Object& x)
    	{
    		//::pthread_mutex_lock(&m_pushLock); //for linux
    		
    		//printf(" push ---->>>>(%#x) \n",(long)workqWp);
    		
    		MY_X_LOCK(&m_wlock);
    
    		//MY_X_LOCK(&workqWp->qlock);
    		
    		//保护临界资源
    		if(workqWp->writable ){
    			workqWp->data = x;
    
    			workqWp->writable = 0x00;
    
    			//MY_X_UNLOCK(&workqWp->qlock);
    
    			MY_COND_SEND(workqWp->qready);
    
    			workqWp = workqWp->next;
    		}
    		else {
    			printf("buffer full \n");
    		}
    		
    		MY_X_UNLOCK(&m_wlock);
    	}
    
    	/*
    	*add by lqh
    	*block_time_ms : unit is ms.
    	*/
    	int front(Object& x, long block_time_ms)
    	{
    		int ret = -1;
    
    		//MY_X_LOCK(&workqRp->qlock);
    
    		if(workqRp->writable) 
    		{
    			if ( block_time_ms < 0 ) {	
    
    				MY_COND_WIAT(workqRp->qready ,INFINITE);
    				ResetEvent(workqRp->qready);//重置为无信号状态
    				if ( !workqRp->writable ) {
    				 	x = workqRp->data;
    					workqRp->writable = 0x01;
    					ret = 0;
    				}
    
    				//MY_X_UNLOCK(&workqRp->qlock);
    
    				if(ret == 0 ){
    					workqRp = workqRp->next;
    				}
    				return ret;
    			}
    			else{
                    //
    				//等待信号被触发 阻塞等待,超时时间 block_time_ms 毫秒
                    //
    				if(MY_COND_WIAT(workqRp->qready, block_time_ms) != WAIT_OBJECT_0) {
    					ResetEvent(workqRp->qready);//重置为无信号状态
    					//printf("unlock timeout \n");
    					//MY_X_UNLOCK(&workqRp->qlock);
    					return -1;
    				}else {
    					//printf("fffff->\n");
    					ResetEvent(workqRp->qready);//重置为无信号状态
    					//
    					//此时workqRp->qlock 已经被释放了
    					//
    					if ( !workqRp->writable ) {
    					 	x = workqRp->data;
    						workqRp->writable = 0x01;
    						ret = 0;
    					}
    
    					//MY_X_UNLOCK(&workqRp->qlock);
    					
    					if(ret == 0 ){
    						workqRp = workqRp->next;
    					}
    					return ret;
    				}
    			}
    		}
    		else {
    
    			if ( !workqRp->writable ) {
    				 x = workqRp->data;
    				workqRp->writable = 0x01;
    				ret = 0;
    			}
    
    
    			//MY_X_UNLOCK(&workqRp->qlock);
    
    			if(ret == 0 ){
    				workqRp = workqRp->next;
    			}
    		}
    
    		return ret;
    	}
    
    	
    private:
    
    	void init()
    	{
    		int i =0;
    		Node* temp;
    
    		workq = static_cast<struct Node*>(::malloc( sizeof(struct Node) * theSize ));
    		/*
    		*create a rink buffer !
    		*/
    	
    		temp = workq;
    		do{
    			
    			temp->writable = 0x01;
    			temp->qready = MY_COND_CREATE();
    			//MY_X_LOCK_INIT (&temp->qlock);
    			if(i == (theSize - 1)){
    				temp->next = workq;
    			}
    			else{
    				temp->next = (Node*)((char*)temp + sizeof(Node));
    				temp = temp->next;
    			}
                i ++;
    		}while( i < theSize);
    
    		workqRp = workq;
    		workqWp = workq;
    		MY_X_LOCK_INIT(&m_wlock);
    	}
    	
    	void clear()
    	{ 
    		Node* temp = workq->next;
    		while(workq != temp) {
    			MY_X_LOCK_DEINIT(&temp->qlock);
    			MY_COND_DESTROY(temp->qready);
    			temp = temp->next;
    		}
    		free(workq);
    		MY_X_LOCK_DEINIT(&m_wlock);
    	}
    
    private:
    	struct Node{
    		Object data;
    		HANDLE  qready;//
    		//CRITICAL_SECTION qlock;                  // mutex
    		int writable;
    		Node* next;
    		Node(const Object& d = Object() ,  Node* n = NULL):data(d) ,next(n) ,writable(1){}
    	};
    
    	int theSize;
    	Node *workq  ;
    	Node *workqRp ;
    	Node *workqWp ;
    	
    	CRITICAL_SECTION m_wlock;
    
    };
    
    #endif
    
    

     下面是测试子程序

    // code.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "msgQueue.h" 
    //
    //
    CRITICAL_SECTION wlock;
    int i = 1;
    typedef struct {
    	int _conut;
    	char _string[128];
    }messageNode;
    
    class message{
    public:
    	message(){m_message = NULL;}
    	~message(){if(m_message) free(m_message);}
    	void* GetMessage(){return m_message;}
    	void ResetMessage(int len) {
    		if(m_message) free(m_message);
    		m_message = (void*)malloc(len);
    		memset(m_message, 0, len);
    	}
    private:
    	void* m_message;
    	int len;
    };
    
    
    
    DWORD WINAPI MYProducerThread(LPVOID);
    DWORD WINAPI MYConsumerThread(LPVOID);
    
    int _tmain(int argc, _TCHAR* argv[])
    {	
    	InitializeCriticalSection(&wlock);
    	HANDLE handle[3];
    	MSGQueue<message*>* g_msgQueue = new MSGQueue<message*>(10); //多线程共享该队列
    	handle[0] = CreateThread(NULL, 0, MYProducerThread, g_msgQueue, 0, NULL);	//生产者线程1
    	handle[1] = CreateThread(NULL, 0, MYProducerThread, g_msgQueue, 0, NULL);	//生产者线程2
    	handle[2] = CreateThread(NULL, 0, MYConsumerThread, g_msgQueue, 0, NULL);		//消费者线程3
    	while(1){
    		Sleep(1000);
    	}
    	return 0;
    }
    DWORD WINAPI MYProducerThread(LPVOID param)
    {
    		MSGQueue<message*>* g_msgQueue = (MSGQueue<message*>*)param;
    
    		while(1) {
    			MY_X_LOCK(&wlock);
    			message* msg = new message();
    			messageNode* messageData;
    			msg->ResetMessage(sizeof(messageNode));
    			messageData = (messageNode*)msg->GetMessage();
    			messageData->_conut = i++;
    			sprintf(messageData->_string,"this 第 %d 生产 ",messageData->_conut);
    			printf("producer: %d, %s \n", messageData->_conut, messageData->_string);
    			g_msgQueue->push(msg);
    			MY_X_UNLOCK(&wlock);
    			//g_msgQueue->push()
    			Sleep(100);
    
    	}
    }
    
    DWORD WINAPI MYConsumerThread(LPVOID param)
    {
    	MSGQueue<message*>* g_msgQueue = (MSGQueue<message*>*)param;
    	int i = 1;
    	while(1) {
    		message* msg;
    		if(g_msgQueue->front( msg,50) == 0) {
    			messageNode* messageData;
    			messageData = (messageNode*)msg->GetMessage();
    			printf("%d, %s \n", messageData->_conut, messageData->_string);
    			delete msg;
    		}
    		else {
    			printf("time out \n");
    		}
    
    	}
    }
    

     

     

     

    展开全文
  • Window下奇怪问题记录

    2011-03-08 18:55:00
    DOS运行cmd /c attrib "c:/program files" -s -h Program Files就出现了.. 删除一个空文件夹时候显示“文件正被另一个程序使用”无法删除,请问如何查到使用这个文件的程序? 用unlocker解锁,然后del 磁盘转...
  • Window10编译openjdk8

    2021-05-01 03:29:10
    关于偏向,无论是书籍还是博客,都没有清晰的说明。于是想自己研究,最终决定自己编译jdk。 参考文档https://github.com/unofficial-openjdk/openjdk/blob/jdk8u/jdk8u/README-builds.html。每个openjdk版本build...
  • 程序功能大概如下: 1、采用单例模式对vfw进行封装; 2、用c++实现类似队列的功能 3、在获取视频数据时没有使用线程,而是使用队列,增加效率 4、使用方便,注释很多,可供参考~
  • WORKAREA_ADDRESS(这个字段在V$SQL_WORKAREA_ACTIVE和V$SQL_...也类似是对象的中介一样。是一种表示地址的句柄)的值。Each SQL statement stored in the shared pool has one or more childcursors that are lis
  • 这样划分后,多次按C-Tab(我把这个快捷键绑定到了命令other-window上),便可以按照左上、左下、右上、右下的顺序轮换当前聚焦的window了。 如果需要从其它window中复制内容到当前window中粘贴,操作会麻烦一点。...
  • Win7系统共享文件夹后共享文件夹上的小图标取消方法 故障现象: 共享后的文件夹图标左下角显示,取消共享后依然存在(如图所示) 问题分析: Window7中小其实是开启简单共享后,文件本身访问权限受限的...
  • Windows 自旋分析(一)

    千次阅读 2016-03-30 11:14:54
    自旋是一种在内核定义,只能在内核态使用的同步机制。自旋用来保护共享数据或者资源,使得并发执行的程序或者在高优先级IRQL的对称多处理器的程序能够正确访问这些数据。分析Windows自旋,首先需要介绍...
  • 原因:键盘上的Window Lock导致window按键无效。 解决方案:按WindowLock即可解锁。 win lock 键的用法:点击一次该按键,即可锁定左下角的win键,防止游戏中误按到win键而退出游戏。
  • Mac键盘住了怎么办

    2021-03-01 09:12:10
    对于经常使用window系统的小伙伴们,突然之间接触MacOS系统会有一些措手不及。如果突然之间按到什么不知名的快捷键,将mac键盘住了该怎么解锁呢?下面小编为大家带来具体解决方法,快来学习一下吧! 解决方法 1.在...
  • window.open 模拟模态窗口效果

    千次阅读 2010-11-10 18:30:52
    比较常见的是window.showModalDialog(),这种方法有很多局限性,比如窗口之间的通信不方便,只在ie有效等。如果采用window.open()的方式,子窗口又不能住父窗口。网上有许多通过层来屏蔽父窗口的例子,但是也都...
  • DB2查看快照

    2010-03-10 17:45:36
    window环境在db2cmd,使用db2 get snapshot for locks on dbname  
  • 支持操作系统 Dos , Windows3x , Windows9x , Windows NT , Windows2000 , WindowXP , Windows2003 , Mac , SCO UNIX , LINUX , AIX UNIX , SOLARIS UNIX 等 支持 190 多种开发语言 圣天诺产品的优势 ...
  • 巧用析构函数解锁

    2012-08-29 23:43:52
    由于最近经常用到的操作,所以打算写一篇文章记录相关的操作和感想。以下就用临界区(Window平台)举例子。 假如有个SetVal函数,该函数需要用到加锁和解锁,该函数有多个出口,第1版本的SetVal代码如下: int...
  • 临近发版时,同事突然找我帮忙看一个statusbar旋转的问题:应用主页只支持竖屏(有子页面需要横屏,所以app还是需要支持portrait、landscapeLeft、landscapeRight三个方向),打卡手机的横竖屏,旋转手机,只支持 ...
  • UWP的Unity项目,在PC上运行时,如果锁屏(手动或自动)再解锁,游戏画面和...在App的窗口被隐藏、切换到后台状况Window.Current.CoreWindow.Activated事件会被触发,参数中有bool值来表明当前主窗口是否是激活...
  • 我们在很多情况想要获得计算机的硬件或操作系统的信息,比如获得CPU序列号给自己的软件添加机器码绑定指定电脑。又或者想要获得硬盘分区,声卡显卡等信息。 开篇: 我们用到的主要类是Ma...
  • Window 核心编程 PDF 清晰版 目 录 译者序 前言 第一部分 程序员必读 第1章 对程序错误的处理 1 1.1 定义自己的错误代码 4 1.2 ErrorShow示例应用程序 5 第2章 Unicode 11 2.1 字符集 11 2.1.1 单字节与双字节字符集...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 210
精华内容 84
关键字:

window下锁