windowslinux線程

① linux和windows多線程的異同

Linux的線程是共享內存空間的多個進程，windows是一個進程。windows線程之間相互作用比linux強

② 如何在Windows和Linux下獲取當前線程的ID號

Linux下獲取當前線程ID號函數：
pthread_t pthread_self();
返回：當前線程的ID號
pthread_t 數據類型的定義如下：
typedef unsigned long int pthread_t;
sizeof(pthread_t) = 4，4個位元組的整數。

Windows下獲取當前線程ID號的函數：
DWORD GetCurrentThreadId();
返回值：當前線程的ID號
DWORD數據類型定義：
typedef unsigned long DWORD;

在Windows下pthread-win庫的pthread_t定義如下：
typedef struct {
void * p; /*Pointer to actual object */
unsigned int x; /*Extra information - reuse count etc */
} ptw32_handle_t;
typedef ptw32_handle_t pthread_t;
與Linux的thread_t不一樣，它是一個結構，不是一個整數值

在Windows和Linux下可用的獲取線程ID號的內聯函數如下：
#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif
inline unsigned int PthreadSelf()
{
#ifdef WIN32
return::GetCurrentThreadId();
#else
returnthread_self();
#endif
}

③ 如何在windows下進行Linux線程編程

下載codeblocks，帶MinGW的那個。
裝好後，開發環境和gcc都有了，其中的含有pthread庫。
在使用的時候需要連接pthread的庫。

④ 用C語言在windows或者Linux上面，編寫一個多線程程序

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int *pt=(int*)lpParam;

printf("I am tread %d\r\n",*pt);
}
int main()
{
const int Count=4;
int datas[Count];
DWORD dwThreadId[Count];
HANDLE hThread[Count];
int i;

for(i=0;i<Count;i++)
{
datas[i]=i+1;
hThread[i]=CreateThread(NULL,0,ThreadProc,&datas[i],0,&dwThreadId[i]);
}
WaitForMultipleObjects(Count,hThread,TRUE,INFINITE);
for(i=0;i<Count;i++)
{
CloseHandle(hThread[i]);
}
system("PAUSE");
return EXIT_SUCCESS;
}

⑤ linux和windows多線程的異同

linux下線程的實現，linux的線程編程有兩個庫pthread和pth,對於pthread的實現是內核方式的實現，每個線程在kernel中都有task結構與之對應，也就是說用ps命令行是可以看見多個線程，線程的調度也是由內核中的schele進行的。 再來看看Windows的多線程，Windows NT和Windows95是一個搶先型多任務、多線程操作系統。因為它使用搶先型的多任務，所以它擁有與UNIX同樣平滑的處理和進程獨立。多線程就更進一步。一個獨立的程序默認是使用一個線程，不過它可以將自己分解為幾個獨立的線程來執行，例如，其中的一個線程可以發送一個文件到列印機，而另一個可以響應用戶的輸入。這個簡單的程序設計修改可以明顯減少用戶等待的時間，讓用戶無需擔心長時間的計算、重繪屏幕、文件讀寫等帶來的不便。
多線程還可以讓你從許多高端的多處理器NT機器中得到好處。例如，你購買了一個高級的RISC機器，可以使用多達10個CPU晶元，但在開始的時候你只購買了一個CPU。你寫了一個簡單的Mandelbrot set程序，你發現需要15秒的時間來重新繪制Mandelbrot set的畫面。

⑥ linux和windows多線程的異同

linux多線程及線程同步和windows的多線程之間的異同

並不是所有的程序都必須採用多線程，有時候採用多線程性能還不如單線程。採用多線程的好處如下：

(1)多線程之間採用相同的地址空間，共享大部分的數據，和多進程相比，代價比較節儉，而啟動新的進程必須分配給它獨立的地址空間，需要數據表來維護代碼段，數據段和堆棧段等等。

(2)對不同進程來說，它們具有獨立的數據空間，要進行數據的傳遞只能通過通信的方式進行，費時而且不方便。多線程之間可以直接共享數據，比如共享全局變數。共享全局變數要注意變數的同步性，不然容易引起災難性的後果。

(3)在多cpu的情況下，不同的線程可以運行在不同的cpu下，這樣就完全並行了。

在這種情況下，採用多線程比較理想。比如要做一個任務分2個步驟，為提高工作效率可以多線程技術開辟2個線程，第一個線程做第一步，第2個線程做第2步。這個時候要注意同步。因為只有第一步做完才能做第2步的工作。這時，可以採用同步技術進行線程之間的通信。

針對這種情況，講解一下多線程之間的通信，在windows平台下，多線程之間通信採用的方法主要有：

(1)共享全局變數,比如上面的問題，第一步要向第2步傳遞收據，可以共享全局變數，讓兩個線程之間傳遞數據，這時主要考慮的問題就是變數的同步，因為後面的線程在對數據進行操作的時候，第一個線程又改變了數據的內容，不同步保護，後果很嚴重（即讀回臟數據）。這種情況下，容易想到的同步方法是設置一個bool flag，比如在第2個線程還沒有用完數據前，第一個線程不能寫入。有時在2個線程所需的時間不相同的時候，怎樣達到最大效率的同步，就比較麻煩。 這時可以多開幾個緩沖區進行操作。如果是2個線程一直在跑，由於時間不一致，緩沖區遲早會溢出。在這種情況下要考慮：是不讓數據寫入還是讓數據覆蓋掉舊的數據。這時候要具體問題具體分析。即用bool變數控制同步，linux 和windows是一樣的。

同樣針對上面的這個問題，共享全局變數同步問題。除了採用bool變數外，還有互斥量。即加鎖。windows下加鎖和linux下加鎖是類似的。採用互斥量進行同步，要想進入那段代碼，就先必須獲得互斥量。

windows下互斥量的函數有：createmutex()創建一個互斥量，然後就是獲得互斥量waitforsingleobject()函數，用完了就釋放互斥量ReleaseMutex(hMutex)，當減到 0的時候 內核會才會釋放其對象。下面是windows下與互斥的幾個函數原型。

HANDLE WINAPI CreateMutex(
__in LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in BOOL bInitialOwner,
__in LPCTSTR lpName

⑦ Windows/Linux下進程相對於線程更安全是因為什麼

多進程下，每個進程都有自己的獨立地址空間，進程間的數據空間也相互獨立，彼此通信以專門的通信方式進行。而多線程下，同一進程內的線程共享進程的地址空間，一個線程的數據可以直接提供給其他線程使用。有時候，特別是在對臨界資源使用時，當臨界資源被一個線程佔有，如果它終止時不釋放佔有的臨界資源，而這個臨界資源仍然認為它還被這個退出的線程使用，因而永遠得不到釋放。如果另外一個線程也在等待這個臨界資源，它就可能無限等待下去，從而形成死鎖，所以從這講也是不安全的。

⑧ 淺談linux 多線程編程和 windows 多線程編程的異同

很早以前就想寫寫linux下多線程編程和windows下的多線程編程了，但是每當寫時又不知道從哪個地方寫起，怎樣把自己知道的東西都寫出來，下面我就談談linux多線程及線程同步，並將它和windows的多線程進行比較，看看他們之間有什麼相同點和不同的地方。
其實最開始我是搞windows下編程的，包括windows編程，windows 驅動，包括usb驅動，ndis驅動,pci驅動，1394驅動等等，同時也一條龍服務，做windows下的應用程序開發，後面慢慢的我又對linux開發產生比較深的興趣和愛好，就轉到搞linux開發了。在接下來的我還會寫一些博客，主要是寫linux編程和windows編程的區別吧，現在想寫的是linux下usb驅動和windows下usb驅動開發的區別，這些都是後話，等我將linux多線程和windows多線程講解完後，我再寫一篇usb驅動，談談windows 和linux usb驅動的東東。好了，言歸正傳。開始將多線程了。
首先我們講講為什麼要採用多線程編程，其實並不是所有的程序都必須採用多線程，有些時候採用多線程，性能還沒有單線程好。所以我們要搞清楚，什麼時候採用多線程。採用多線程的好處如下：
(1)因為多線程彼此之間採用相同的地址空間，共享大部分的數據，這樣和多進程相比，代價比較節儉，因為多進程的話，啟動新的進程必須分配給它獨立的地址空間，這樣需要數據表來維護代碼段，數據段和堆棧段等等。
(2)多線程和多進程相比，一個明顯的優點就是線程之間的通信了，對不同進程來說，它們具有獨立的數據空間，要進行數據的傳遞只能通過通信的方式進行，這種方式不僅費時，而且很不方便。但是對於多線程就不一樣了。他們之間可以直接共享數據，比如最簡單的方式就是共享全局變數。但是共享全部變數也要注意哦，呵呵，必須注意同步，不然後果你知道的。呵呵。
(3)在多cpu的情況下，不同的線程可以運行不同的cpu下，這樣就完全並行了。
反正我覺得在這種情況下，採用多線程比較理想。比如說你要做一個任務分2個步驟，你為提高工作效率，你可以多線程技術，開辟2個線程，第一個線程就做第一步的工作，第2個線程就做第2步的工作。但是你這個時候要注意同步了。因為只有第一步做完才能做第2步的工作。這時，我們可以採用同步技術進行線程之間的通信。
針對這種情況，我們首先講講多線程之間的通信，在windows平台下，多線程之間通信採用的方法主要有：
(1)共享全局變數,這種方法是最容易想到的，呵呵，那就首先講講吧，比如說吧，上面的問題，第一步要向第2步傳遞收據，我們可以之間共享全局變數，讓兩個線程之間傳遞數據，這時主要考慮的就是同步了，因為你後面的線程在對數據進行操作的時候，你第一個線程又改變了數據的內容，你不同步保護，後果很嚴重的。你也知道，這種情況就是讀臟數據了。在這種情況下，我們最容易想到的同步方法就是設置一個bool flag了，比如說在第2個線程還沒有用完數據前，第一個線程不能寫入。有時在2個線程所需的時間不相同的時候，怎樣達到最大效率的同步，就比較麻煩了。咱們可以多開幾個緩沖區進行操作。就像生產者消費者一樣了。如果是2個線程一直在跑的，由於時間不一致，緩沖區遲早會溢出的。在這種情況下就要考慮了，是不讓數據寫入還是讓數據覆蓋掉老的數據，這時候就要具體問題具體分析了。就此打住，呵呵。就是用bool變數控制同步，linux 和windows是一樣的。
既然講道了這里，就再講講其它同步的方法。同樣 針對上面的這個問題，共享全局變數同步問題。除了採用bool變數外，最容易想到的方法就是互斥量了。呵呵，也就是傳說中的加鎖了。windows下加鎖和linux下加鎖是類似的。採用互斥量進行同步，要想進入那段代碼，就先必須獲得互斥量。
linux上互斥量的函數是：
windows下互斥量的函數有：createmutex 創建一個互斥量，然後就是獲得互斥量waitforsingleobject函數，用完了就釋放互斥量ReleaseMutex(hMutex)，當減到0的時候 內核會才會釋放其對象。下面是windows下與互斥的幾個函數原型。
HANDLE WINAPI CreateMutex(
__in LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in BOOL bInitialOwner,
__in LPCTSTR lpName
);
可以可用來創建一個有名或無名的互斥量對象
第一參數 可以指向一個結構體SECURITY_ATTRIBUTES一般可以設為null；
第二參數 指當時的函數是不是感應感應狀態 FALSE為當前擁有者不會創建互斥
第三參數 指明是否是有名的互斥對象 如果是無名 用null就好。
DWORD WINAPI WaitForSingleObject(
__in HANDLE hHandle,
__in DWORD dwMilliseconds
);
第一個是 創建的互斥對象的句柄。第二個是 表示將在多少時間之後返回 如果設為宏INFINITE 則不會返回 直到用戶自己定義返回。
對於linux操作系統，互斥也是類似的，只是函數不同罷了。在linux下，和互斥相關的幾個函數也要閃亮登場了。
pthread_mutex_init函數：初始化一個互斥鎖；
pthread_mutex_destroy函數：注銷一個互斥鎖；
pthread_mutex_lock函數：加鎖，如果不成功，阻塞等待；
pthread_mutex_unlock函數：解鎖；
pthread_mutex_trylock函數：測試加鎖，如果不成功就立即返回，錯誤碼為EBUSY;
至於這些函數的用法，google上一搜，就出來了，呵呵，在這里不多講了。windows下還有一個可以用來保護數據的方法，也是線程同步的方式
就是臨界區了。臨界區和互斥類似。它們之間的區別是，臨界區速度快，但是它只能用來同步同一個進程內的多個線程。臨界區的獲取和釋放函數如下：
EnterCriticalSection() 進入臨界區; LeaveCriticalSection()離開臨界區。 對於多線程共享內存的東東就講到這里了。
(2)採用消息機制進行多線程通信和同步，windows下面的的消息機制的函數用的多的就是postmessage了。Linux下的消息機制，我用的較少，就不在這里說了，如果誰熟悉的，也告訴我，呵呵。
(3)windows下的另外一種線程通信方法就是事件和信號量了。同樣針對我開始舉得例子，2個線程同步，他們之間傳遞信息，可以採用事件(Event)或信號量(Semaphore),比如第一個線程完成生產的數據後，就必須告訴第2個線程，他已經把數據准備好了，你可以來取走了。第2個線程就把數據取走。呵呵，這里可以採用消息機制，當第一個線程准備好數據後，就直接postmessage給第2個線程，按理說採用postmessage一個線程就可以搞定這個問題了。呵呵，不是重點，省略不講了。
對於linux，也有類似的方法，就是條件變數了，呵呵，這里windows和linux就有不同了。要特別講講才行。
對於windows，採用事件和信號量同步時候，都會使用waitforsingleobject進行等待的，這個函數的第一個參數是一個句柄，在這里可以是Event句柄，或Semaphore句柄，第2個參數就是等待的延遲，最終等多久，單位是ms，如果這個參數為INFINITE，那麼就是無限等待了。釋放信號量的函數為ReleaseSemaphore（）；釋放事件的函數為SetEvent。當然使用這些東西都要初始化的。這里就不講了。Msdn一搜，神馬都出來了，呵呵。神馬都是浮雲！
對於linux操作系統，是採用條件變數來實現類似的功能的。Linux的條件變數一般都是和互斥鎖一起使用的，主要的函數有：
pthread_mutex_lock ,
pthread_mutex_unlock,
pthread_cond_init
pthread_cond_signal
pthread_cond_wait
pthread_cond_timewait
為了和windows操作系統進行對比，我用以下表格進行比較：

對照以上表格,總結如下：
(1) Pthread_cleanup_push,Pthread_cleanup_pop：
這一對函數push和pop的作用是當出現異常退出時，做一些清除操作，即當在push和pop函數之間異常退出，包括調用pthread_exit退出，都會執行push裡面的清除函數，如果有多個push，注意是是棧，先執行後面的那個函數，在執行前面的函數，但是注意當在這2個函數之間通過return 退出的話，執不執行push後的函數就看pop函數中的參數是不是為0了。還有當沒有異常退出時，等同於在這裡面return退出的情況，即：當pop函數參數不為0時，執行清除操作，當pop函數參數為0時，不執行push函數中的清除函數。
（2）linux的pthread_cond_signal和SetEvent的不同點
Pthread_cond_singal釋放信號後，當沒有Pthread_cond_wait，信號馬上復位了，這點和SetEvent不同，SetEvent是不會復位的。詳解如下：
條件變數的置位和復位有2種常用模型：第一種模型是當條件變數置位時(signaled)以後，如果當前沒有線程在等待，其狀態會保持為置位(signaled)，直到有等待的線程進入被觸發,其狀態才會變為unsignaled,這種模型以採用Windows平台上的Auto-set Event 為代表。
第2種模型則是Linux平台的pthread所採用的模型，當條件變數置位(signaled)以後，即使當前沒有任何線程在等待，其狀態也會恢復為復位(unsignaled)狀態。
條件變數在Linux平台上的這種模型很難說好壞，在實際應用中，我們可以對
代碼稍加改進就可以避免這種差異的發生。由於這種差異只會發生在觸發沒有被線程等待在條件變數的時刻，因此我們只需要掌握好觸發的時機即可。最簡單的做法是增加一個計數器記錄等待線程的個數，在決定觸發條件變數前檢查該變數即可。
示例 使用 pthread_cond_wait() 和 pthread_cond_signal()
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count()
{
pthread_mutex_lock(&count_lock);
while (count == 0)
pthread_cond_wait(&count_nonzero, &count_lock);
count = count - 1;
pthread_mutex_unlock(&count_lock);
}
increment_count()
{
pthread_mutex_lock(&count_lock);
if (count == 0)
pthread_cond_signal(&count_nonzero);
count = count + 1;
pthread_mutex_unlock(&count_lock);
}
(3) 注意Pthread_cond_wait條件返回時互斥鎖的解鎖問題
extern int pthread_cond_wait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));
調用這個函數時,線程解開mutex指向的鎖並被條件變數cond阻塞。線程可以被函數pthread_cond_signal和函數 pthread_cond_broadcast喚醒線程被喚醒後，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這里，被等待被下一次喚醒。如果在多線程中採用pthread_cond_wait來等待時，會首先釋放互斥鎖，當等待的信號到來時，再次獲得互斥鎖，因此在之後要注意手動解鎖。舉例如下：
#include
#include
#include
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /*初始化互斥鎖*/
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化條件變數
void *thread1(void *);
void *thread2(void *);
int i=1;
int main(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,NULL,thread1,(void *)NULL);/*創建進程t_a*/
pthread_create(&t_b,NULL,thread2,(void *)NULL); /*創建進程t_b*/
pthread_join(t_b, NULL);/*等待進程t_b結束*/
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
exit(0);
}
void *thread1(void *junk)
{
for(i=1;i<=9;i++)
{
printf("IN one\n");
pthread_mutex_lock(&mutex);//
if(i%3==0)
pthread_cond_signal(&cond);/*，發送信號，通知t_b進程*/
else
printf("thead1:%d\n",i);
pthread_mutex_unlock(&mutex);//*解鎖互斥量*/
printf("Up Mutex\n");
sleep(3);
}
}
void *thread2(void *junk)
{
while(i<9)
{
printf("IN two \n");
pthread_mutex_lock(&mutex);
if(i%3!=0)
pthread_cond_wait(&cond,&mutex);/*等待*/
printf("thread2:%d\n",i);
pthread_mutex_unlock(&mutex);
printf("Down Mutex\n");
sleep(3);
}
}
輸出如下：
IN one
thead1:1
Up Mutex
IN two
IN one
thead1:2
Up Mutex
IN one
thread2:3
Down Mutex
Up Mutex
IN one
thead1:4
Up Mutex
IN two
IN one
thead1:5
Up Mutex
IN one
Up Mutex
thread2:6
Down Mutex
IN two
thread2:6
Down Mutex
IN one
thead1:7
Up Mutex
IN one
thead1:8
Up Mutex
IN two
IN one
Up Mutex
thread2:9
Down Mutex
注意藍色的地方，有2個thread2:6，其實當這個程序多執行幾次，i=3和i=6時有可能多列印幾個，這里就是競爭鎖造成的了。
(4)另外要注意的Pthread_cond_timedwait等待的是絕對時間，這個和WaitForSingleObject是不同的，Pthread_cond_timedwait在網上也有討論。如下：這個問題比較經典，我把它搬過來。
thread_a ：
pthread_mutex_lock(&mutex);
//do something
pthread_mutex_unlock(&mutex)
thread_b：
pthread_mutex_lock(&mutex);
//do something
pthread_cond_timedwait(&cond, &mutex, &tm);
pthread_mutex_unlock(&mutex)
有如上兩個線程thread_a, thread_b,現在如果a已經進入了臨界區，而b同時超時了，那麼b會從pthread_cond_timedwait返回嗎？如果能返回，那豈不是a,b都在臨界區？如果不能返回，那pthread_cond_timedwait的定時豈不是就不準了？
大家討論有價值的2點如下：
（1） pthread_cond_timedwait (pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *abstime) -- This function is a time-based variant of pthread_cond_wait. It waits up to abstime amount of time for cv to be notified. If abstime elapses before cv is notified, the function returns back to the caller with an ETIME result, signifying that a timeout has occurred. Even in the case of timeouts, the external_mutex will be locked when pthread_cond_timedwait returns.
（2） 2.1 pthread_cond_timedwait行為和pthread_cond_wait一樣，在返回的時候都要再次lock mutex.
2 .2pthread_cond_timedwait所謂的如果沒有等到條件變數，超時就返回，並不確切。
如果pthread_cond_timedwait超時到了，但是這個時候不能lock臨界區，pthread_cond_timedwait並不會立即返回，但是在pthread_cond_timedwait返回的時候，它仍在臨界區中，且此時返回值為ETIMEDOUT。
關於pthread_cond_timedwait超時返回的問題，我也認同觀點2。
附錄：
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
返回值：若成功則返回0，否則返回出錯編號
返回成功時，由tidp指向的內存單元被設置為新創建線程的線程ID。attr參數用於制定各種不同的線程屬性。新創建的線程從start_rtn函數的地址開始運行，該函數只有一個無指針參數arg，如果需要向start_rtn函數傳遞的參數不止一個，那麼需要把這些參數放到一個結構中，然後把這個結構的地址作為arg的參數傳入。
linux下用C開發多線程程序，Linux系統下的多線程遵循POSIX線程介面，稱為pthread。
由 restrict 修飾的指針是最初唯一對指針所指向的對象進行存取的方法，僅當第二個指針基於第一個時，才能對對象進行存取。對對象的存取都限定於基於由 restrict 修飾的指針表達式中。 由 restrict 修飾的指針主要用於函數形參，或指向由 malloc() 分配的內存空間。restrict 數據類型不改變程序的語義。 編譯器能通過作出 restrict 修飾的指針是存取對象的唯一方法的假設，更好地優化某些類型的常式。
第一個參數為指向線程標識符的指針。
第二個參數用來設置線程屬性。
第三個參數是線程運行函數的起始地址。
第四個參數是運行函數的參數。
因為pthread不是linux系統的庫，所以在編譯時注意加上-lpthread參數，以調用靜態鏈接庫。
終止線程：
如果在進程中任何一個線程中調用exit或_exit,那麼整個進行會終止，線程正常的退出方式有：
（1） 線程從啟動常式中返回(return)
（2） 線程可以被另一個進程終止（kill）；
（3） 線程自己調用pthread_exit函數
#include
pthread_exit
線程等待：
int pthread_join(pthread_t tid,void **rval_ptr)
函數pthread_join用來等待一個線程的結束。函數原型為：
extern int pthread_join __P (pthread_t __th, void **__thread_return);
第一個參數為被等待的線程標識符，第二個參數為一個用戶定義的指針，它可以用來存儲被等待線程的返回值。這個函數是一個線程阻塞的函數，調用它的函數將一直等待到被等待的線程結束為止，當函數返回時，被等待線程的資源被收回。
對於windows線程的創建東西，就不列舉了，msdn上 一搜就出來了。呵呵。今天就講到這里吧，希望是拋磚引玉，大家一起探討，呵呵。部分內容我也是參考internet的，特此對原作者表示感謝！

⑨ 淺談linux和windows的線程機制的區別

-
轉載自fychit創意空間 早前想寫寫linux線程編程windows線程編程每寫知道哪寫起自知道東西都寫面我談談linux線程及線程同步並windows線程進行比較看看間相同點同

其實始我搞windows編程包括windows編程windows 驅包括usb驅ndis驅,pci驅1394驅等等同條龍服務做windows應用程序發面慢慢我linux發產比較深興趣轉搞linux發接我寫些博客主要寫linux編程windows編程區別吧現想寫linuxusb驅windowsusb驅發區別些都等我linux線程windows線程講解完我再寫篇usb驅談談windows linux usb驅東東言歸傳始線程

首先我講講要採用線程編程其實並所程序都必須採用線程些候採用線程性能沒單線程所我要搞清楚候採用線程採用線程處：

(1)線程彼間採用相同址空間共享部數據進程相比代價比較節儉進程啟新進程必須配給獨立址空間需要數據表維護代碼段數據段堆棧段等等

(2)線程進程相比明顯優點線程間通信同進程說具獨立數據空間要進行數據傳遞能通通信式進行種式僅費且便於線程間直接共享數據比簡單式共享全局變數共享全部變數要注意哦呵呵必須注意同步知道呵呵

(3)cpu情況同線程運行同cpu完全並行

反我覺種情況採用線程比較理想比說要做任務2步驟提高工作效率線程技術辟2線程第線程做第步工作第2線程做第2步工作候要注意同步第步做完才能做第2步工作我採用同步技術進行線程間通信

針種情況我首先講講線程間通信windows平台線程間通信採用主要：

(1)共享全局變數,種容易想呵呵首先講講吧比說吧面問題第步要向第2步傳遞收據我間共享全局變數讓兩線程間傳遞數據主要考慮同步面線程數據進行操作候第線程改變數據內容同步保護嚴重知道種情況讀臟數據種情況我容易想同步設置bool flag比說第2線程沒用完數據前第線程能寫入2線程所需間相同候達效率同步比較麻煩咱幾緩沖區進行操作像產者消費者2線程直跑由於間致緩沖區遲早溢種情況要考慮讓數據寫入讓數據覆蓋掉數據候要具體問題具體析打住呵呵用bool變數控制同步linux windows

既講道再講講其同步同 針面問題共享全局變數同步問題除採用bool變數外容易想互斥量呵呵傳說加鎖windows加鎖linux加鎖類似採用互斥量進行同步要想進入段代碼先必須獲互斥量

linux互斥量函數：

windows互斥量函數：createmutex 創建互斥量獲互斥量waitforsingleobject函數用完釋放互斥量ReleaseMutex(hMutex)減0候 內核才釋放其象面windows與互斥幾函數原型

HANDLE WINAPI CreateMutex(
__in LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in BOOL bInitialOwner,
__in LPCTSTR lpName
);
用創建名或名互斥量象
第參數 指向結構體SECURITY_ATTRIBUTES般設null；
第二參數 指函數應應狀態 FALSE前擁者創建互斥
第三參數 指明否名互斥象 名 用null

DWORD WINAPI WaitForSingleObject(

__in HANDLE hHandle,

__in DWORD dwMilliseconds

);

第 創建互斥象句柄第二 表示少間返 設宏INFINITE 則返 直用戶自定義返

於linux操作系統互斥類似函數同罷linux互斥相關幾函數要閃亮登場

pthread_mutex_init函數：初始化互斥鎖；

pthread_mutex_destroy函數：注銷互斥鎖；

pthread_mutex_lock函數：加鎖功阻塞等待；

pthread_mutex_unlock函數：解鎖；

pthread_mutex_trylock函數：測試加鎖功立即返錯誤碼EBUSY;

至於些函數用google搜呵呵講windows用保護數據線程同步式

臨界區臨界區互斥類似間區別臨界區速度快能用同步同進程內線程臨界區獲取釋放函數：

EnterCriticalSection() 進入臨界區; LeaveCriticalSection()離臨界區 於線程共享內存東東講

(2)採用消息機制進行線程通信同步windows面消息機制函數用postmessageLinux消息機制我用較少說誰熟悉告訴我呵呵

(3)windows另外種線程通信事件信號量同針我始舉例2線程同步間傳遞信息採用事件(Event)或信號量(Semaphore),比第線程完產數據必須告訴第2線程已經數據准備取走第2線程數據取走呵呵採用消息機制第線程准備數據直接postmessage給第2線程按理說採用postmessage線程搞定問題呵呵重點省略講

於linux類似條件變數呵呵windowslinux同要特別講講才行

於windows採用事件信號量同步候都使用waitforsingleobject進行等待函數第參數句柄Event句柄或Semaphore句柄第2參數等待延遲終等久單位ms參數INFINITE限等待釋放信號量函數ReleaseSemaphore（）；釋放事件函數SetEvent使用些東西都要初始化講Msdn搜神馬都呵呵神馬都浮雲

於linux操作系統採用條件變數實現類似功能Linux條件變數般都互斥鎖起使用主要函數：

pthread_mutex_lock ,

pthread_mutex_unlock,

pthread_cond_init

pthread_cond_signal

pthread_cond_wait

pthread_cond_timewait

⑩ windows與linux在某一項的比較，比如線程管理或內存方面的比較

熟悉WIN32編程的人一定知道，WIN32的進程管理方式與Linux上有著很大區別，在UNIX里，只有進程的概念，但在WIN32里卻還有一個"線程"的概念，那麼Linux和WIN32在這里究竟有著什麼區別呢？

WIN32里的進程/線程是繼承自OS/2的。在WIN32里，"進程"是指一個程序，而"線程"是一個"進程"里的一個執行"線索"。從核心上講， WIN32的多進程與Linux並無多大的區別，在WIN32里的線程才相當於Linux的進程，是一個實際正在執行的代碼。但是，WIN32里同一個進程里各個線程之間是共享數據段的。這才是與Linux的進程最大的不同。

下面這段程序顯示了WIN32下一個進程如何啟動一個線程。

int g;

DWORD WINAPI ChildProcess( LPVOID lpParameter ){

int i;

for ( i = 1; i <1000; i ++) {

g ++;

printf( "This is Child Thread: %d\n", g );

}

ExitThread( 0 );

};

void main()

{

int threadID;

int i;

g = 0;

CreateThread( NULL, 0, ChildProcess, NULL, 0, &threadID );

for ( i = 1; i <1000; i ++) {

g ++;

printf( "This is Parent Thread: %d\n", g );

}

}

在WIN32下，使用CreateThread函數創建線程，與Linux下創建進程不同，WIN32線程不是從創建處開始運行的，而是由 CreateThread指定一個函數，線程就從那個函數處開始運行。此程序同前面的UNIX程序一樣，由兩個線程各列印1000條信息。 threadID是子線程的線程號，另外，全局變數g是子線程與父線程共享的，這就是與Linux最大的不同之處。大家可以看出，WIN32的進程/線程要比Linux復雜，在Linux要實現類似WIN32的線程並不難，只要fork以後，讓子進程調用ThreadProc函數，並且為全局變數開設共享數據區就行了，但在WIN32下就無法實現類似fork的功能了。所以現在WIN32下的C語言編譯器所提供的庫函數雖然已經能兼容大多數Linux/UNIX的庫函數，但卻仍無法實現fork。

對於多任務系統，共享數據區是必要的，但也是一個容易引起混亂的問題，在WIN32下，一個程序員很容易忘記線程之間的數據是共享的這一情況，一個線程修改過一個變數後，另一個線程卻又修改了它，結果引起程序出問題。但在Linux下，由於變數本來並不共享，而由程序員來顯式地指定要共享的數據，使程序變得更清晰與安全。

至於WIN32的"進程"概念，其含義則是"應用程序"，也就是相當於UNIX下的exec了