typedef struct {
  const char *name;
  uint32_t attr_bits;
  void *cb_mem;
  uint32_t cb_size;
  void *stack_mem;
  uint32_t stack_size;
  osPriority_t priority;
  TZ_ModuleId_t tz_module;
  uint32_t reserved;
} osThreadAttr_t;

osThreadId_t osThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr);

sStatus_t status = osThreadTerminate(osThreadId_t tid);

if(count > 0){
	count--;
}

typedef struct {
  /** Mutex name */
  const char                   *name;
  /** Reserved attribute bits */
  uint32_t                 attr_bits;
  /** Memory for the mutex control block */
  void                      *cb_mem;
  /** Size of the memory for the mutex control block */
  uint32_t                   cb_size;
} osMutexAttr_t;

osMutexId_t osMutexNew(const osMutexAttr_t *attr);

osStatus_t osMutexAcquire(osMutexId_t mutex_id, uint32_t timeout);

typedef enum {
  /** Operation completed successfully */
  osOK                      =  0,
  /** Unspecified error */
  osError                   = -1,
  /** Timeout */
  osErrorTimeout            = -2,
  /** Resource error */
  osErrorResource           = -3,
  /** Incorrect parameter */
  osErrorParameter          = -4,
  /** Insufficient memory */
  osErrorNoMemory           = -5,
  /** Service interruption */
  osErrorISR                = -6,
  /** Reserved. It is used to prevent the compiler from optimizing enumerations. */
  osStatusReserved          = 0x7FFFFFFF
} osStatus_t;

osStatus_t osMutexRelease(osMutexId_t mutex_id);

#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"

// 模擬動(dòng)物園門票數(shù)
static int count = 100;

// 售票業(yè)務(wù)線程
void outThread(void *args){
    // 獲取互斥鎖
    osMutexId_t *mid = (osMutexId_t *)args;
    // 每個(gè)線程都在不停地買票
    while(1){
        // 獲取鎖，進(jìn)入業(yè)務(wù)流程
        if(osMutexAcquire(*mid, 100) == osOK){
            if(count > 0){
                count--;
                // 設(shè)置提示信息
                printf("[Mutex Test] Thread %s get a value, the less is %d.\r\n", osThreadGetName(osThreadGetId()), count);
            } else {
                // 告知這些線程已經(jīng)沒有門票賣了，線程結(jié)束
                printf("[Mutex Test] The value is out!\r\n");
                osThreadTerminate(osThreadGetId());
            }
        }
        // 釋放鎖
        osMutexRelease(*mid);

        osDelay(5);
    }
}
// 創(chuàng)建線程封裝
osThreadId_t createThreads(char *name, osThreadFunc_t func, void *args){
    osThreadAttr_t attr = {
        name, 0, NULL, 0, NULL, 1024, osPriorityNormal, 0, 0
    };
    osThreadId_t tid = osThreadNew(func, args, &attr);
    return tid;
}

// 主函數(shù)實(shí)現(xiàn)多線程的創(chuàng)建，執(zhí)行買票業(yè)務(wù)
void mutexMain(void){
    // 創(chuàng)建互斥鎖
    osMutexAttr_t attr = {0};

    // 獲取互斥鎖的id
    osMutexId_t mid = osMutexNew(&attr);

    if(mid == NULL){
        printf("[Mutex Test] Failed to create a mutex!\r\n");
    }

    // 創(chuàng)建多線程
    osThreadId_t tid1 = createThreads("Thread_1", (osThreadFunc_t)outThread, &mid);
    osThreadId_t tid2 = createThreads("Thread_2", (osThreadFunc_t)outThread, &mid);
    osThreadId_t tid3 = createThreads("Thread_3", (osThreadFunc_t)outThread, &mid);

    osDelay(1000);

}

// 測試線程
void MainTest(void){
    osThreadId_t tid = createThreads("MainTest", (osThreadFunc_t)mutexMain, NULL);
}

APP_FEATURE_INIT(MainTest);

static_library("mutex_demo"){
    sources = [
        "mutex.c"
    ]
    include_dirs = [
        "http://commonlibrary/utils_lite/include",
        "http://device/soc/hisilicon/hi3861v100/hi3861_adapter/kal/cmsis"
    ]
}

if(osMutexAcquire(*mid, 100) == osOK){
            if(count > 0){
                count--;
                printf("[Mutex Test] Thread %s get a value, the less is %d.\r\n", osThreadGetName(osThreadGetId()), count);
            } else {
                printf("[Mutex Test] The value is out!\r\n");
                osThreadTerminate(osThreadGetId());
            }
        }

osSemaphoreId_t osSemaphoreNew(uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr);

osStatus_t osSemaphoreAcquire(osSemaphoreId_t semaphore_id, uint32_t timeout)；

#define osWaitForever         0xFFFFFFFFU

osStatus_t osSemaphoreRelease(osSemaphoreId_t semaphore_id);

#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"

// 售票口 4
#define OUT_NUM 4
// 檢票口 2
#define IN_NUM 2

// 信號(hào)量
osSemaphoreId_t sid;

// 待檢票人數(shù)
static int people = 0;

// 售票業(yè)務(wù)
void outThread(void *args){
    // 獲取互斥鎖
    osMutexId_t *mid = (osMutexId_t *)args;

    while(1){
        if(osMutexAcquire(*mid, 100) == osOK){
            // 賣一張票，帶檢票的人數(shù)就會(huì)加一位
            people++;
            printf("[SEMAPHORE TEST] out, people: %d.\r\n", people);
        }
        osMutexRelease(*mid);
        osDelay(50);
    }
}

// 檢票業(yè)務(wù)
void inThread(void *args){
    // 獲取信號(hào)量
    osSemaphoreAcquire(sid, osWaitForever);
    while(1){
        if(people > 0){
            people--;
            printf("[SEMAPHORE TEST] in, people: %d.\r\n", people);
        }
        osSemaphoreRelease(sid);
        osDelay(100);
    }
}

// 創(chuàng)建線程封裝
osThreadId_t createThreads(char *name, osThreadFunc_t func, void *args){
    osThreadAttr_t attr = {
        name, 0, NULL, 0, NULL, 1024 * 2, osPriorityNormal, 0, 0
    };
    osThreadId_t tid = osThreadNew(func, args, &attr);
    return tid;
}

// 主線程
void SemaphoreMain(void){
    // 創(chuàng)建信號(hào)量
    sid = osSemaphoreNew(IN_NUM, IN_NUM, NULL);

    // 創(chuàng)建互斥鎖
    osMutexAttr_t attr = {0};

    // 獲取互斥鎖的id
    osMutexId_t mid = osMutexNew(&attr);

    // 創(chuàng)建售票線程
    for(int i = 0; i < OUT_NUM; i++){
        createThreads("", (osThreadFunc_t)outThread, &mid);
    }

    // 創(chuàng)建檢票線程
    for(int i = 0; i < IN_NUM; i++){
        createThreads("", (osThreadFunc_t)inThread, NULL);
    }
}

// 測試函數(shù)
void MainTest(){
    createThreads("MainTest", (osThreadFunc_t)SemaphoreMain, NULL);
}

APP_FEATURE_INIT(MainTest);

static_library("semaphore_demo"){
    sources = [
        "semaphore.c"   
    ]
    include_dirs = [
        "http://utils/native/lite/include",
    ]
}

#### 消息隊(duì)列API

osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr);

osStatus_t osMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout);

osStatus_t osMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout);

osStatus_t osMessageQueueDelete (osMessageQueueId_t mq_id);

#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"

// 定義消息隊(duì)列的大小
#define QUEUE_SIZE 15

// 定義請(qǐng)求數(shù)量
#define REQ_SIZE 10

// 定義消息的結(jié)構(gòu)
typedef struct{
    osThreadId_t tid;
} message_queue;

// 創(chuàng)建消息隊(duì)列id
osMessageQueueId_t qid;

// 模擬發(fā)送業(yè)務(wù)
void sendThread(void){
    // 定義一個(gè)消息結(jié)構(gòu)
    message_queue sentry;
    sentry.tid = osThreadGetId();

    osDelay(100);

    // 消息入隊(duì)
    osMessageQueuePut(qid, (const void*)&sentry, 0, osWaitForever);

    // 設(shè)置提示信息
    printf("[MESSAGEQUEUE TEST] %d send a message.\r\n", sentry.tid);
}

// 模擬處理業(yè)務(wù)
void receiverThread(void){
    // 定義一個(gè)消息結(jié)構(gòu)
    message_queue rentry;
    int less = 5;
    while(less > 0){
        osMessageQueueGet(qid, (void *)&rentry, NULL, osWaitForever);
        less--;
        printf("[MESSAGEQUEUE TEST] %d get a product, less = %d.\r\n", rentry.tid, less);
        osDelay(5);
    }
    printf("[MESSAGEQUEUE TEST] over!\r\n");
}

// 創(chuàng)建線程封裝
osThreadId_t createThreads(char *name, osThreadFunc_t func, void *args){
    osThreadAttr_t attr = {
        name, 0, NULL, 0, NULL, 1024 * 2, osPriorityNormal, 0, 0
    };
    osThreadId_t tid = osThreadNew(func, args, &attr);
    return tid;
}

// 主線程
void MessageQueueMain(void){
    // 創(chuàng)建一個(gè)消息隊(duì)列
    qid = osMessageQueueNew(QUEUE_SIZE, sizeof(message_queue), NULL);

    // 創(chuàng)建發(fā)送線程
    for(int i = 0; i < REQ_SIZE; i++){
        createThreads("", (osThreadFunc_t)sendThread, NULL);
    }
    osDelay(5);

    // 創(chuàng)建接收線程
    createThreads("", (osThreadFunc_t)receiverThread, NULL);

    osDelay(500);

    // 刪除消息隊(duì)列
    osMessageQueueDelete(qid);
}

// 測試函數(shù)
void MainTest(){
    createThreads("MainTest", (osThreadFunc_t)MessageQueueMain, NULL);
}

APP_FEATURE_INIT(MainTest);

static_library("queue_demo"){
    sources = [
        "queue.c",
    ]
    include_dirs = [
        "http://utils/native/lite/include",
    ]
}