2. 程式人生 > >jni中的執行緒, 同步以及生產者消費者模式

jni中的執行緒, 同步以及生產者消費者模式

阿新 • • 發佈：2018-12-09
  • 編譯環境centos6.×64

執行緒建立以及結束

#include <pthread.h>
pthread_create (thread, attr, start_routine, arg)

連線和分離執行緒

pthread_join (threadid, status) 
pthread_detach (threadid)

pthread_join() 子程式阻礙呼叫程式，直到指定的 threadid 執行緒終止為止。

例子1


#include <unistd.h>
#include <pthread.h>
 


void* thr_fun(void* arg){
    char* no = (char*)arg;
    int i = 0;
    for(; i < 10; i++){
        printf("%s thread, i:%d\n",no,i);
        if(i==5){
            //執行緒退出（自殺）
            pthread_exit(2);
            //他殺pthread_cancel          
        }
    }   
    return 1;
}   


void main(){
    //執行緒的引用
 

    pthread_t tid;
    pthread_create(&tid,NULL,thr_fun,"執行緒1");
    void *rval;
    pthread_join(tid,&rval);
    printf("執行緒結束%d\n",rval);

}

程式碼意思,pthread_create開啟了執行緒,當thr_fun遍歷10次,當第5次的時候退出執行緒.

  • 編譯命令: gcc test1.c -o main -lpthread

  • 執行 結果 

[root@host threadDemo]# ./main
執行緒1 thread, i:
 
0
執行緒1 thread, i:1
執行緒1 thread, i:2
執行緒1 thread, i:3
執行緒1 thread, i:4
執行緒1 thread, i:5
執行緒結束 2

例子2

多執行緒問題


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

int i=0;
void* thr_fun(void* arg){
        char* no = (char*)arg;

        for(; i < 10; i++){
                printf("%s thread, i:%d\n",no,i);
                sleep(1);
        }
        i=0;
        return 1;

}
void main(){
        //執行緒的引用
        pthread_t tid,tid2;
        pthread_create(&tid,NULL,thr_fun,"執行緒1");
        pthread_create(&tid2,NULL,thr_fun,"執行緒2");

        void *rval;
         pthread_join(tid,&rval);
         pthread_join(tid2,&rval);
        printf("執行緒結束 %d",rval);

}

編譯出來main2 執行後 每隔一秒先列印執行緒2 然後列印i

可以看出 是兩個執行緒搶佔使用thr_fun 出現這種結果 .

如果我想每個執行緒單獨列印i ,應該怎麼做 : 同步 

[root@host threadDemo]# gcc 02.c -o main2 -lpthread
[root@host threadDemo]# ls
02.c  main  main2  test1.c  thread01.c
[root@host threadDemo]# ./main2
執行緒2 thread, i:0
執行緒1 thread, i:0
執行緒2 thread, i:1
執行緒1 thread, i:2
執行緒2 thread, i:3
執行緒1 thread, i:4
執行緒2 thread, i:5
執行緒1 thread, i:6
執行緒2 thread, i:7
執行緒1 thread, i:8
執行緒2 thread, i:9
執行緒2 thread, i:1
執行緒2 thread, i:2
執行緒2 thread, i:3
執行緒2 thread, i:4
執行緒2 thread, i:5
執行緒2 thread, i:6
執行緒2 thread, i:7
執行緒2 thread, i:8
執行緒2 thread, i:9
執行緒結束 1

執行緒的同步

  • 現在的目的: 第一個執行緒全部輸出完成後,第二個執行緒再去列印.

int pthread_mutex_init 是一條指令，是中斷指令的標識。 該函式用於C函式的多執行緒程式設計中，互斥鎖的初始化。 (類似 synchronized 作用)

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); posix下抽象了一個鎖型別的結構：ptread_mutex_t。通過對該結構的操作，來判斷資源是否可以訪問。 顧名思義，加鎖(lock)後，別人就無法開啟，只有當鎖沒有關閉(unlock)的時候才能訪問資源。 即物件互斥鎖的概念，來保證共享資料操作的完整性。每個物件都對應於一個可稱為” 互斥鎖” 的標記， 這個標記用來保證在任一時刻，只能有一個執行緒訪問該物件。

引數一 建立一個鎖 引數二指定了新建互斥鎖的屬性。如果引數attr為NULL，則使用預設的互斥鎖屬性，預設屬性為快速互斥鎖

  • PTHREAD_MUTEX_TIMED_NP，這是預設值，也就是普通鎖。當一個執行緒加鎖以後，其餘請求鎖的執行緒將形成一個等待佇列，並在解鎖後按優先順序獲得鎖。這種鎖策略保證了資源分配的公平性。
  • PTHREAD_MUTEX_RECURSIVE_NP，巢狀鎖，允許同一個執行緒對同一個鎖成功獲得多次，並通過多次unlock解鎖。如果是不同執行緒請求，則在加鎖執行緒解鎖時重新競爭。
  • PTHREAD_MUTEX_ERRORCHECK_NP，檢錯鎖，如果同一個執行緒請求同一個鎖，則返回EDEADLK，否則與PTHREAD_MUTEX_TIMED_NP型別動作相同。這樣就保證當不允許多次加鎖時不會出現最簡單情況下的死鎖。
  • PTHREAD_MUTEX_ADAPTIVE_NP，適應鎖，動作最簡單的鎖型別，僅等待解鎖後重新競爭。

程式碼: 

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
int i=0;
//鎖物件
pthread_mutex_t mutex;
void* thr_fun(void* arg){

        char* no = (char*)arg;
       //加鎖的程式碼塊
        pthread_mutex_lock(&mutex);
        for(; i < 10; i++){
                printf("%s thread, i:%d\n",no,i);
               sleep(1);
        }
        //取消鎖
        pthread_mutex_unlock(&mutex);
        i=0;
        return 1;
}


void main(){
        //互斥鎖的初始化        
        pthread_mutex_init(&mutex,NULL);
        //執行緒初始化
        pthread_t tid1,tid2;
        pthread_create(&tid1,NULL,thr_fun,"執行緒1");
        pthread_create(&tid2,NULL,thr_fun,"執行緒2");

        void *rval;
        pthread_join(tid1,&rval);
        pthread_join(tid2,&rval);
        printf("執行緒結束%d\n",rval);
        //銷燬鎖
        pthread_mutex_destroy(&mutex);
}

列印結果: 

[[email protected] threadDemo]# gcc 02.c -o main2 -lpthread
02.c: In function ‘thr_fun’:
02.c:20: warning: return makes pointer from integer without a cast
[[email protected] threadDemo]# ls
02.c  main  main2  test1.c  thread01.c
[[email protected] threadDemo]# ./main2
執行緒2 thread, i:0
執行緒2 thread, i:1
執行緒2 thread, i:2
執行緒2 thread, i:3
執行緒2 thread, i:4
執行緒2 thread, i:5
執行緒2 thread, i:6
執行緒2 thread, i:7
執行緒2 thread, i:8
執行緒2 thread, i:9
執行緒1 thread, i:0
執行緒1 thread, i:1
執行緒1 thread, i:2
執行緒1 thread, i:3
執行緒1 thread, i:4
執行緒1 thread, i:5
執行緒1 thread, i:6
執行緒1 thread, i:7
執行緒1 thread, i:8
執行緒1 thread, i:9
執行緒結束1

可以看到 先列印了執行緒二執行的輸入 結束之後才打印執行緒一的輸出.

生產者消費者

阻塞在條件變數上pthread_cond_wait

解除在條件變數上的阻塞pthread_cond_signal

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

//模擬 產品佇列
int ready = 0;

//互斥鎖
pthread_mutex_t mutex;

//條件變數 判斷是否有產品
pthread_cond_t has_product;

//生產者
void* produce(void *arg){
        char* name = (char*)arg;
        for(;;) {
                //鎖住
                pthread_mutex_lock(&mutex);
                ready++;//生產進入佇列
                printf("%s  生產 %d \n",name,ready);
                //傳送一條解鎖訊息
                pthread_cond_signal(&has_product);
                //解鎖
                pthread_mutex_unlock(&mutex);
                sleep(3);
        }
}

//消費者
void* consumer(void* arg){
        char* name = (char*)arg;
        for(;;){
                //加鎖
                pthread_mutex_lock(&mutex);
                //如果產品列表為空 繼續等待, 因為有可能不止一個消費者
                while(ready==0){
                        printf("沒有產品了,等待生產\n");
                        //等待
                        pthread_cond_wait(&has_product,&mutex);
                }
                //消費 出佇列
                printf("%s 消費%d\n",name,ready);
                ready--;
                printf(" 當前產品%d\n",ready);
                //解鎖
                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

void main(){
        //互斥鎖初始化
        pthread_mutex_init(&mutex,NULL);
        //條件變數初始化
        pthread_cond_init(&has_product,NULL);
        //執行緒的引用 這裡三個 一個生產兩個消費
        pthread_t tid1,tid2,tid3;
        pthread_create(&tid1,NULL,produce,"生產者1");
        pthread_create(&tid2,NULL,consumer,"消費者1");
        pthread_create(&tid3,NULL,consumer,"消費者2");

        printf("開啟執行緒");
        void *rval;
        pthread_join(tid1,&rval);
        pthread_join(tid2,&rval);
        pthread_join(tid3,&rval);
        printf("執行緒結束%d\n",rval);
}

結果: 

開啟執行緒沒有產品了,等待生產
沒有產品了,等待生產
生產者1  生產 1 
消費者2 消費1
 當前產品0
沒有產品了,等待生產
生產者1  生產 1 
消費者1 消費1
 當前產品0
沒有產品了,等待生產
生產者1  生產 1 
消費者2 消費1
 當前產品0
沒有產品了,等待生產
生產者1  生產 1 
消費者1 消費1
 當前產品0
沒有產品了,等待生產
生產者1  生產 1 
消費者2 消費1
 當前產品0
沒有產品了,等待生產
生產者1  生產 1 
消費者1 消費1
 當前產品0
沒有產品了,等待生產

生產者消費者模式.

相關推薦

jni中的執行緒, 同步以及生產者消費者模式

編譯環境centos6.×64 執行緒建立以及結束 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 連線和分離執行緒 pthrea

Qt之執行緒同步（生產者消費者模式

 簡述 生產者將資料寫入緩衝區，直到它到達緩衝區的末尾，此時，它將從開始位置重新啟動，覆蓋現有資料。消費者執行緒讀取資料並將其寫入標準錯誤。 Semaphore（訊號量） 比 mutex（互斥量）有一個更高階的併發性。如果緩衝區的訪問由一個 QMutex 把守，當生產者

多執行緒,同步,互斥(生產者/消費者)

資料汙讀：bool 的 true   和   bool 的 false , 當1執行緒執行true時讀檔案, 為false時2執行緒讀檔案,但是由於執行緒的cpu分時複用,可能還會執行 true 操作 , 導致讀入資料異常 .    &

Python 多執行緒|Queue佇列|生產者消費者模式|

Queue佇列 Python中，佇列是執行緒間最常用的交換資料的形式。Queue模組是提供佇列操作的模組，雖然簡單易用，但是不小心的話，還是會出現一些意外。Queue是執行緒安全的，自帶鎖，使用的時候，不用對佇列加鎖操作。 1. 將一個值放入佇列中 q.get()呼叫佇列物件的get

java多執行緒同步以及執行緒間通訊詳解&amp;消費者生產者模式&amp;死鎖&amp;Thread.join()（多執行緒程式設計之二）

從執行結果，我們就可以看出我們4個售票視窗同時賣出了1號票，這顯然是不合邏輯的，其實這個問題就是我們前面所說的執行緒同步問題。不同的執行緒都對同一個資料進了操作這就容易導致資料錯亂的問題，也就是執行緒不同步。那麼這個問題該怎麼解決呢？在給出解決思路之前我們先來分析一下這個問題是怎麼產生的？我們宣告一個執行緒類

Qt執行緒同步一個生產者多個消費者的實現

        根據QMutex和QSemaphore的特點，我們可以實現一個生成者對應多個消費者的的生產者模型。可參考：       互斥量可以鎖定一次，而訊號量可以在設定上限大小的情況下，獲取多次，可以用來保護一定數量的同種資源。在使用acquire函式跨執行緒獲取n個資

並行，JUC，併發（賣票），執行緒通訊（生產者消費者問題））

併發和並行 併發： 多個執行緒搶一份資源。比如說12306 搶票。 並行：泡方便麵。正常追求效率的情況下，撕調料包的情況下，燒熱水。比如說一個人執行了多個任務，在聽歌的時候走路。 關於兩者的區別關注下面的這個連線： The Differences 併發會引發的問

java中執行緒同步的幾種方法

方法一： 使用synchronized關鍵字  由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時， 內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。 注： synchronized關鍵字也可以修飾靜態方法，此時如果呼叫該靜態方法，將會

多執行緒初探之生產者消費者

前言 對於java開者而言，多執行緒開發是不可避免的，多執行緒程式相對於單執行緒程式穩定性更強，一個執行緒掛了不會影響整個程式的正常執行。在多cup的機器上，多執行緒更加具有效率上的優勢。但是多執行緒也會導致一些問題，集中出現在資料方面。當多個執行緒操作同一個資料來源的時候就會出現讀

JAVA中執行緒同步的方法（7種）彙總

同步的方法： 一、同步方法 　　即有synchronized關鍵字修飾的方法。 由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時， 內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。 注： synchronized關鍵字也可以修飾靜態

JAVA 多執行緒經典案例-生產者消費者模型【使用wait/notify實現】

  生產者消費者模型實現細節 生產者生產產品到公共倉庫，消費者消費公共倉庫中產品。 情況一：當公共倉庫產品達到倉庫容量上限，生產者停止生產； 情況二：當公共倉庫沒有產品，或達到設定的倉庫容量下限，消費者停止消費； 情況三：當公共倉庫產品達到容量上限時，消費者消費一

java中執行緒同步的理解（非常通俗易懂）

Java中執行緒同步的理解 我們可以在計算機上執行各種計算機軟體程式。每一個執行的程式可能包括多個獨立執行的執行緒（Thread）。 執行緒（Thread）是一份獨立執行的程式，有自己專用的執行棧。執行緒有可能和其他執行緒共享一些資源，比如，記憶體，檔案，資料庫等。

java中執行緒同步Synchronized，監視器monitor和鎖lock的關係是什

既然有關監視器monitor的概念比較難，大家怎麼解釋的都有。首先我給出一下java的官方文件，也是最權威的解釋： Synchronizationis built around an internal entity known as the intrinsic lock ormonitor lock. (Th

執行緒同步以及執行緒排程相關的方法

- wait()：使一個執行緒處於等待（阻塞）狀態，並且釋放所持有的物件的鎖；  - sleep()：使一個正在執行的執行緒處於睡眠狀態，是一個靜態方法，呼叫此方法要處理InterruptedException異常；  - notify()：喚醒一個處於等待狀態的執行緒，

C++ 作業系統程序中執行緒同步的四種方式

執行緒同步的定義：       同步就是協同步調，按預定的先後次序進行執行。如：你說完，我再說。“同”字從字面上容易理解為一起動作其實不是，“同”字應是指協同、協助、互相配合。如程序、執行緒同步，可理

Linux C/C++多執行緒學習：生產者消費者問題

#include <iostream> #include <mutex> #include <condition_variable> #include <unistd.h> #include <thread> using namespace std;

多執行緒實驗之”生產者——消費者“問題

一 例項  參考書籍《從實踐中學linux應用程式開發》/*producer-customer.c*/ #include <stdio.h> #include <pthread.h> #include <stdlib.h> #inc

執行緒安全的生產者消費者四種實現方法

問題描述 在IT技術面試過程中，我們經常會遇到生產者消費者問題(Producer-consumer problem)， 這是多執行緒併發協作問題的經典案例。場景中包含三個物件，生產者(Producer)，消費者(Consumer)以及一個固定大小的緩衝區(Buffer)。生產者的主要作用是不斷生成資料放到緩衝

java多執行緒：執行緒間通訊——生產者消費者模型

# 一、背景 && 定義 多執行緒環境下，只要有併發問題，就要保證資料的安全性，一般指的是通過 synchronized 來進行同步。 另一個問題是，**多個執行緒之間如何協作呢**？ 我們看一個倉庫出貨問題（更具體一些，快餐店直接放好炸貨的架子，不過每次只放一份） 1. 假設倉庫中只能存放一

java 執行緒池、多執行緒併發實戰(生產者消費者模型 1 vs 10) 附案例原始碼

導讀 　　前二天寫了一篇《Java 多執行緒併發程式設計》點我直達，放國慶，在家閒著沒事，繼續寫剩下的東西，開幹！ 執行緒池 為什麼要使用執行緒池 　　例如web伺服器、資料庫伺服器、檔案伺服器或郵件伺服器之類的。請求的時候，單個任務時間很短，但是請求數量巨大。每一次請求，就會建立一個新執行緒，然後在新執行緒