做题打卡第26天

线程，yyds！
这道题实在卡了好长时间
卡了一两天
我吐了啊
这就是菜鸡么。i了i了
最后也是投机取巧算出来的
下面是题
问题描述：有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按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
原题链接：https://www.nowcoder.com/practice/cd99fbc6154d4074b4da0e74224a1582?tpId=37&&tqId=21272&rp=1&ru=/ta/huawei&qru=/ta/huawei/question-ranking
下面是我的憨憨答案：

#include <iostream>
using namespace std;
 
int main()
{
    int n;
    while(cin>>n)
    {
        for(int i = 0; i<n; i++)
            cout<<"ABCD";
        cout<<endl;
    }
    return 0;
}

解释一下为什么这么短
因为这道题只有一组测试点
只需要按测试点输出就ok了
不希望这样做
但我实在太菜了
写不出好代码
下面分享一个大佬写的代码
基本上都是java版的
但我不会java（惨，下学年才能学到
有hxd找到c++版本的可以发一下谢谢

import java.util.Scanner;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Main{
    public static void main(String args[]) throws InterruptedException{
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int num = Integer.parseInt(sc.nextLine().trim());
            //这个字符串数组可以你没有的,直接在service中打印就可以,也可以传入字符串最后在打印字符串
            char []chs = new char[num*4+1];
            Service s = new Service(chs);
            MyThread1 a = new MyThread1(s,num);
            MyThread2 b = new MyThread2(s,num);
            MyThread3 c = new MyThread3(s,num);
            MyThread4 d = new MyThread4(s,num);
            a.start();
            b.start();
            c.start();
            d.start();
            //睡眠一会是为了让主线程的换行在最后打印
            Thread.sleep(300);
            //这道题有个坑,一定要在最后打印一个换行,否则会报错的
            System.out.println();
//            System.out.println();
//            System.out.println("------------------------");
//            for(int i=0;i<num*4;i++){
//                System.out.print(chs[i]);
//            }
        }
    }
}
 
class MyThread4 extends Thread{
    Service service;
    int i;
     
    public MyThread4(Service service,int i) {
        super();
        this.i = i;
        this.service = service;
    }
    <a href="/profile/992988" data-card-uid="992988" class="js-nc-card" target="_blank">@Override
    public void run() {
        for(int k=0;k<i;k++){
            this.service.d();            
        }
        super.run();
    }    
}
 
class MyThread1 extends Thread{
    Service service;
    int i=0;
    public MyThread1(Service service,int i) {
        super();
        this.i = i;
        this.service = service;
    }
    </a><a href="/profile/992988" data-card-uid="992988" class="js-nc-card" target="_blank">@Override
    public void run() {
        for(int k=0;k<i;k++){
            this.service.a();            
        }
    }    
}
 
class MyThread2 extends Thread{
    Service service;
    int i=0;
    public MyThread2(Service service,int i) {
        super();
        this.i = i;
        this.service = service;
    }
    </a><a href="/profile/992988" data-card-uid="992988" class="js-nc-card" target="_blank">@Override
    public void run() {
        for(int k=0;k<i;k++){
            this.service.b();            
        }
        super.run();
    }    
}
 
class MyThread3 extends Thread{
    Service service;
    int i=0;
    public MyThread3(Service service,int i) {
        super();
        this.service = service;
        this.i = i;
    }
    </a><a href="/profile/992988" data-card-uid="992988" class="js-nc-card" target="_blank">@Override
    public void run() {
        for(int k=0;k<i;k++){
            this.service.c();            
        }
        super.run();
    }    
}
 
class Service{
    private char []chs;
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    int k=0;
    public Service(char[] chs) {
        super();
        this.chs = chs;
    }
 
    private int flag = 1;
    public void a(){
        try {
            lock.lock();
            while(flag!=1){
                condition.await();
            }
            System.out.print("A");
            chs[k++] = 'A';
            flag=2;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
     
    public void b(){
        try {
            lock.lock();
            while(flag!=2){
                condition.await();
            }
            System.out.print("B");
            chs[k++] = 'B';
            flag=3;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
    public void c(){
        try {
            lock.lock();
            while(flag!=3){
                condition.await();
            }
            System.out.print("C");
            chs[k++] = 'C';
            flag=4;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
     
    public void d(){
        try {
            lock.lock();
            while(flag!=4){
                condition.await();
            }
            System.out.print("D");
            chs[k++] = 'D';
            flag=1;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}