多线程

题目描述
问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
接口说明：
void init(); //初始化函数
void Release(); //资源释放函数
unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放
unsignedint__stdcall ThreadFun2(PVOID pM) ;//线程函数2，无参数传入
unsignedint__stdcall ThreadFun3(PVOID pM) ;//线程函数3，无参数传入
Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入
char g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
输入描述:
输入一个int整数

输出描述:
输出多个ABCD
示例1
输入
10
输出
ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
 
void* ThreadFun1(void* arg);
void* ThreadFun2(void* arg);
void* ThreadFun3(void* arg);
void* ThreadFun4(void* arg);
pthread_mutex_t fun_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fun1_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t fun2_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t fun3_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t fun4_cond = PTHREAD_COND_INITIALIZER;
char g_write[1032] = {'0'};
int k = 0, end = 0;
int i = 0;
int main()
{
    int ret = -ENOSYS;
    pthread_t fun1;
    pthread_t fun2;
    pthread_t fun3;
    pthread_t fun4;
     
    ret = pthread_create(&fun1, NULL, ThreadFun1, NULL);
    if(ret)
    {
        exit(1);
    }
     
    ret = pthread_create(&fun2, NULL, ThreadFun2, NULL);
    if(ret)
    {
        exit(1);
    }
     
    ret = pthread_create(&fun3, NULL, ThreadFun3, NULL);
    if(ret)
    {
        exit(1);
    }
     
    ret = pthread_create(&fun4, NULL, ThreadFun4, NULL);
    if(ret)
    {
        exit(1);
    }
    while(end == 0)
    {
         
    }
    exit(0);
}
void* ThreadFun1(void* arg)
{
    int j = 0;
    pthread_detach( pthread_self());
    while(scanf("%d", &k) != EOF)
    {
         
        for(j = 0, i = 0; j < k; j++)
        {
            pthread_mutex_lock( &fun_mutex);
            g_write[i] = 'A';
            i++;
            pthread_mutex_unlock( &fun_mutex);
            pthread_cond_signal( &fun1_cond);
            pthread_mutex_lock( &fun_mutex);
            pthread_cond_wait( &fun4_cond, &fun_mutex);
            pthread_mutex_unlock( &fun_mutex);
        }
        printf("%s\n",g_write);
        memset(&g_write, 0, sizeof(g_write));
    }
    end = 1;
    pthread_mutex_destroy ( &fun_mutex );
    pthread_cond_destroy ( &fun1_cond );
    pthread_cond_destroy ( &fun2_cond );
    pthread_cond_destroy ( &fun3_cond );
    pthread_cond_destroy ( &fun4_cond );
    pthread_exit(NULL);
}
 
void* ThreadFun2(void* arg)
{
    pthread_detach( pthread_self());
     
    while(end == 0)
    {
        pthread_mutex_lock( &fun_mutex);
        pthread_cond_wait( &fun1_cond, &fun_mutex);
        g_write[i] = 'B';
        i++;
        pthread_mutex_unlock( &fun_mutex);
        pthread_cond_signal( &fun2_cond);
    }
    pthread_exit(NULL);
}
void* ThreadFun3(void* arg)
{
    pthread_detach( pthread_self());
     
    while(end == 0)
    {
        pthread_mutex_lock( &fun_mutex);
        pthread_cond_wait( &fun2_cond, &fun_mutex);
        g_write[i] = 'C';
        i++;
        pthread_mutex_unlock( &fun_mutex);
        pthread_cond_signal( &fun3_cond);
    }
    pthread_exit(NULL);
}
void* ThreadFun4(void* arg)
{
    pthread_detach( pthread_self());
     
    while(end == 0)
    {
        pthread_mutex_lock( &fun_mutex);
        pthread_cond_wait( &fun3_cond, &fun_mutex);
        g_write[i] = 'D';
        i++;
        pthread_mutex_unlock( &fun_mutex);
        pthread_cond_signal( &fun4_cond);
    }
    pthread_exit(NULL);
}