牛客网华为机试【多线程】

题目描述

问题描述：有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

示例
输入

10
输出

ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD

题目分析

这个题，关键看怎么去想呢。
有的人使用 StringBuilder 直接拼接字符串，也能通过测试。
比如这样写：

import java.io.*;
 
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while ((str = br.readLine()) != null) {
            int num = Integer.parseInt(str);
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < num; i++) {
                sb.append("ABCD");
            }
            System.out.println(sb);
        }
    }
}

但是这题目要用的可不就是多线程的嘛！
我想了一种思路，可是死活调试不过，只有70%通过！但是本地运行又没有任何问题。

我本地运行的结果是这样的：

可是，到了牛客的测试端：

怎么整头疼啊。
要我判断一下最终的那个字符，如果是 A 就去删了最后一个字符？？
不能吧。

下面我把我的java 代码放这，大家谁能看看这到底啥情况？

我简单说一下思路：我这里用的是线程计数器和 volatile 关键字。更新 index 变量，直到最终满足指定的长度即可。

java 代码

import java.util.Scanner;
import java.util.concurrent.CountDownLatch;

public class Main {

    private static volatile int index = 0;
    public static void main(String[] args) throws InterruptedException {
        Scanner input = new Scanner(System.in);

        while(input.hasNextInt()){
            int num = input.nextInt();
            CountDownLatch countDownLatch = new CountDownLatch(num * 4);

            StringBuffer sb = new StringBuffer();
            Thread thread1 = new Thread(() -> {
                while(sb.length() < num * 4){
                    if(index == 0){
                        sb.append("A");
                        index = 1;
                        countDownLatch.countDown();
                    }
                }
            });

            Thread thread2 = new Thread(() -> {
                while(sb.length() < num * 4){
                    if(index == 1){
                        sb.append("B");
                        index = 2;
                        countDownLatch.countDown();
                    }
                }
            });

            Thread thread3 = new Thread(() -> {
                while(sb.length() < num * 4){
                    if(index == 2){
                        sb.append("C");
                        index = 3;
                        countDownLatch.countDown();
                    }
                }
            });

            Thread thread4 = new Thread(() -> {
                while(sb.length() < num * 4){
                    if(index == 3){
                        sb.append("D");
                        index = 0;
                        countDownLatch.countDown();
                    }
                }
            });

            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
            countDownLatch.await();
            System.out.println(sb);
            index = 0;
        }
    }
}

结果

结果就是我上边那个截图的啦。

哪个大佬来看看这有啥问题吗？
我觉得逻辑方面没啥问题啦。