使用Linux平臺上現有的訊號量sem_t相關的一組API，可以方便地進行執行緒同步。現在用pthread_mutex_t和pthread_cond_t相關的一組API實現訊號量機制。這組API包括：pthread_mutex_init，pthread_cond_init，pthread_mutex_lock，pthread_cond_signal，pthread_mutex_unlock，pthread_cond_wait，pthread_cond_timedwait，pthread_cond_destroy和pthread_mutex_destroy，可以在http://www.9linux.com

MySemaphore.h

1. #ifndef Semaphore_Header
2. #define Semaphore_Header
3. #include <iostream>
4. #include <pthread.h>
5. #include <errno.h>
6. #include <assert.h>
7. usingnamespace std;  
8. //------------------------------------------------------------------------
9. class CSemaphoreImpl  
10. {  
11. protected:  
12.     CSemaphoreImpl(int n, int max);       
13.     ~CSemaphoreImpl();  
14.     void SetImpl();  
15.     void WaitImpl();  
16.     bool WaitImpl(long lMilliseconds);  
17. private:  
18.     volatileint    m_n;  
19.     int             m_max;  
20.     pthread_mutex_t m_mutex;  
21.     pthread_cond_t  m_cond;  
22. };  
23. inlinevoid CSemaphoreImpl::SetImpl()  
24. {  
25.     if (pthread_mutex_lock(&m_mutex))     
26.         cout<<"cannot signal semaphore (lock)"<<endl;  
27.     if (m_n < m_max)  
28.     {  
29.         ++m_n;  
30.     }  
31.     else
32.     {  
33.         pthread_mutex_unlock(&m_mutex);  
34.         cout<<"cannot signal semaphore: count would exceed maximum"<<" m_n = "<<m_n<<"m_max = "<<m_max<<endl;  
35.     }  
36.     //重新開始等待m_cond的執行緒，可被排程
37.     if (pthread_cond_signal(&m_cond))  
38.     {  
39.         pthread_mutex_unlock(&m_mutex);  
40.         cout<<"cannot signal semaphore"<<endl;  
41.     }  
42.     pthread_mutex_unlock(&m_mutex);  
43. }  
44. //------------------------------------------------------------------------
45. /* 
46.  訊號量同步機制 
47.  訊號量提供一個計數值，可以進行原子操作。V 將計數值加1，使得 
48.  等待該訊號量的執行緒可以被呼叫（呼叫Set()），P 將計數值減1，使 
49.  當前執行緒被掛起，進行睡眠（呼叫Wait()）。 
50.  當訊號量的計數值被初始化為0時，呼叫P操作，將掛起當前執行緒。 
51.  當訊號量被啟用，即呼叫V操作後，被掛起的執行緒就有機會被重新排程了。 
52. */
53. class CMySemaphore: private CSemaphoreImpl  
54. {  
55. public:  
56.     /* 
57.      建立一個訊號量，訊號量計數值當前值為引數n，最大值為max。 
58.      如果只有n，則n必須大於0；如果同時有n和max,則n必須不小 
59.      於0，且不大於max 
60.     */
61.     CMySemaphore(int n);  
62.     CMySemaphore(int n, int max);  
63.     /* 
64.      銷燬一個訊號量 
65.     */
66.     ~CMySemaphore();  
67.     /* 
68.      對訊號量計數值做加1動作，訊號量變為有訊號狀態，使得 
69.      另一個等待該訊號量的執行緒可以被排程 
70.     */
71.     void Set();  
72.     /* 
73.      對訊號量計數值做減1動作，訊號量變為無訊號狀態。若 
74.      計數值變得大於0時，訊號量才會變為有訊號狀態。 
75.     */
76.     void Wait();  
77.     /* 
78.      在給定的時間間隔裡等待訊號量變為有訊號狀態，若成功， 
79.      則將計數值減1，否則將發生超時。 
80.     */
81.     void Wait(long lMilliseconds);  
82.     /* 
83.      在給定的時間間隔裡等待訊號量變為有訊號狀態，若成功， 
84.      則將計數值減1，返回true；否則返回false。 
85.     */
86.     bool TryWait(long lMilliseconds);  
87. private:  
88.     CMySemaphore();  
89.     CMySemaphore(const CMySemaphore&);  
90.     CMySemaphore& operator = (const CMySemaphore&);  
91. };  
92. inlinevoid CMySemaphore::Set()  
93. {  
94.     SetImpl();  
95. }  
96. inlinevoid CMySemaphore::Wait()  
97. {  
98.     WaitImpl();  
99. }  
100. inlinevoid CMySemaphore::Wait(long lMilliseconds)  
101. {  
102.     if (!WaitImpl(lMilliseconds))  
103.         cout<<"time out"<<endl;  
104. }  
105. inlinebool CMySemaphore::TryWait(long lMilliseconds)  
106. {  
107.     return WaitImpl(lMilliseconds);  
108. }  
109. #endif

1. #include "MySemaphore.h"
2. #include <sys/time.h>
3. CSemaphoreImpl::CSemaphoreImpl(int n, int max): m_n(n), m_max(max)  
4. {  
5.     assert (n >= 0 && max > 0 && n <= max);  
6.     if (pthread_mutex_init(&m_mutex, NULL))  
7.         cout<<"cannot create semaphore (mutex)"<<endl;  
8.     if (pthread_cond_init(&m_cond, NULL))  
   相關推薦

   Linux平臺用C++實現訊號量，同步執行緒

       使用Linux平臺上現有的訊號量sem_t相關的一組API，可以方便地進行執行緒同步。現在用pthread_mutex_t和pthread_cond_t相關的一組API實現訊號量機制。這組API包括：pthread_mutex_init，pthread_cond_init，pthread_mu

   用C++封裝Win32訊號量，同步執行緒

        在Win32環境下編寫多執行緒應用程式，也會常用到訊號量Semaphore來進行執行緒同步。與其相關的一組API包括：CreateSemaphore，ReleaseSemaphore，WaitForSingleObject，和CloseHandle。關於這些API

   Linux下用C實現域名到IP的轉換（域名解析）

   只需呼叫一個函式即可gethostbyname()，gethostbyname()返回對應於給定主機名的包含主機名字和地址資訊的hostent結構指標。結構的宣告與gethostaddr()中一致。下面是函式原型： Windows平臺下 #include <winsock2.h>

   Linux下用C實現串列埠讀寫

    http://hi.baidu.com/weiweisuo1986/item/b33200134ceaac6871d5e81d         之前要做一個和串列埠相關的專案，才認真研究了下串列埠，首先就是要實現串列埠和PC機的通訊。          串列埠的驅動一般不需要我們寫，都是很成熟的驅動

   Linux下用C++實現通過程序名稱獲取程序ID

   近期開發的系統功能涉及到程序之間的查詢、程序對程序的啟停操作。 在shell環境下，使用程序名稱查詢程序ID非常簡單，例如通過 ps -ef | grep "proc_name"來檢視名為“proc_name”程序， 也可以通過pidof "proc_name"來獲取程序

   linux程序間的通訊(C): 使用訊號量進行同步的共享記憶體機制

   semaphore.c /* * \File * semaphore.c * \Breif * */ #include <stdio.h> #include <stdlib.h> #include <

   （轉）用C++11的std::async代替執行緒的建立， 以及std::future，std::promise和std::packaged_task的使用

   c++11中增加了執行緒，使得我們可以非常方便的建立執行緒，它的基本用法是這樣的： void f(int n); std::thread t(f, n + 1); t.join(); 但是執行緒畢竟是屬於比較低層次的東西，有時候使用有些不便，比如我希望獲取執

   Linux下用C語言判斷程式是否已執行

   通過程式名獲得程序號，然後和當前程式程序號做對比。 int isRunning() { int ret = 0; char sCurrPid[16] = {0}; spri

   c++單例模式，多執行緒使用

   c++ 11保證了這樣做是執行緒安全的。 一:class Singleton{ static Singleton* GetInstance(){         static Singleton s;     

   【Django】Uwsgi+Nginx+Django2.0+Python3.7實現高併發，多執行緒，高效能

   一、系統以及環境 伺服器系統：Ubuntu 16.04 專案環境：python 3.7 框架：Django2.0 伺服器環境：Uwsgi、Nginx 效能監測工具：Uwsgitop 使用背景：因為Dj

   day 32 管道,訊號量,程序池,執行緒的建立

   1.管道(瞭解) Pipe():  在程序之間建立一條通道,並返回元組(conn1,conn2),其中conn1,conn2表示管道兩端的連線物件,強調一點:必須在產生Process物件之前產生管道. from multiprocessing import Process,Pi

   訊號量解決經典執行緒同步問題

          訊號量 是E. W.Dijkstra在l965年提出的一種方法，它使用一個整型變數來累計喚醒次數，以供以後使用。在他的建議中引入一個新的變號型別，稱作訊號量(semapore )。一個訊號量的值可以為0,表示沒有積累下來的喚醒操作;或者為正值，表示有一個或多個

   C++實現一個簡單的雙執行緒MVC框架

           花了一上午，初步實現一個簡單的MVC框架，原理如下： 兩個執行緒一個控制執行緒(處理業務邏輯的工作執行緒)，一個檢視使用執行緒(往往應該就是UI執行緒)。所有檢視操作應該在UI執行緒中操作，業務邏輯和對model的修改在工作執行緒中做。 實現控制器類Prin

   jdbc操作 資料庫同步，全量，加入執行緒，批處理

   動態資料庫的全量、增量同步，多執行緒增加效能，批處理。 程式碼可以直接執行： 同步的類： import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.Dri

   用C++11的std::async代替執行緒的建立and std::future、std::promise和std::packaged_task

   c++11中增加了執行緒，使得我們可以非常方便的建立執行緒，它的基本用法是這樣的： void f(int n); std::thread t(f, n + 1); t.join(); 　　但是執行緒畢竟是屬於比較低層次的東西，有時候使用有些不便，比如我希望獲取執行緒函式的返回結果的時候，我就不能直接通過

   java中的互斥鎖,訊號量和多執行緒等待機制

   互斥鎖和訊號量都是作業系統中為併發程式設計設計基本概念，互斥鎖和訊號量的概念上的不同在於，對於同一個資源，互斥鎖只有0和1 的概念，而訊號量不止於此。也就是說，訊號量可以使資源同時被多個執行緒訪問，而互斥鎖同時只能被一個執行緒訪問 互斥鎖在java中的實現就是 Reetr

   Java訊號量控制多執行緒併發

   package com.uusafe.thread2;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.S

   linux多執行緒程式設計(C)：訊號量實現的執行緒安全佇列

   用訊號量實現的執行緒安全佇列。 簡單有用的示例程式， 比起互斥量的實現在多執行緒時效率更好。 cir_queue.h /* * \File * cir_queue.h * \Brief * circular queue */#ifndef __CIR_QUEUE_H_

   Linux c/c++後端程式設計，訊號量，遮蔽和不遮蔽，訊號捕獲；

   0x01 緣起 在 linux c/c++後端程式設計的過程中，我們經常對捕獲和捕獲一些訊號的處理。主要是在程式收到相關訊號時能進行安全的退出，做一些善後處理。 如下場景： Linux下的執行緒實質上是輕量級程序(light weighted process),執行緒生成時

   linux c 執行緒間同步（通訊）的幾種方法--互斥鎖，條件變數，訊號量，讀寫鎖

   轉載自：https://blog.csdn.net/vertor11/article/details/55657619Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。 下面是思維導圖： 一、互斥鎖（mutex） 　　鎖機制是同一時刻只允