问题：

如何在Task1、Task2、Task3类run（）方法中为threadArray变量赋值？

羊舌承

2023-03-14

> < li>

我必须通过创建三个类，即Task1、Task2和Task3，使用三个线程来插入元素。要插入数组的值是0，1，2，....299.

在线程中重写run方法。三个整数I、j和k表示每个线程应该在给定数组中添加的元素数量。

线程一应该在数组内将0追加到i-1，线程二应该在数组内将I追加到i j-1，第三个线程应该在数组内将i j追加到299。

线程一和线程二必须同时运行，并且线程一和线程二的值必须随机插入到从0到i j-1的数组索引中。第三个线程应该在前两个线程完全执行完之后才开始。

在这些代码中，给出了三个任务。第一个任务和第二个任务同时开始执行线程，在前两个任务完成后，只有第三个任务开始。如果这些情况正确，则test（）方法返回true。

公共静态最终int[]threadArray=new int[300]；我如何使用Task1 Task2和Task3类将随机数添加到这些数组中。

输入：

80颗

130

输出：

真实的

     import java.util.Scanner;

   class Task1 extends Thread
   {
    static int a = 0;
    static int beg = 0;
    
    public void run() 
    {
        for(int i=a;i<=beg;i++)
        {
            Solution.threadArray[i] = i;  
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }   
     }
   }

   class Task2 extends Thread
   {
     static int a = 0;
     static int beg = 0;
    
    @Override
    public void run() 
    {
        // TODO Auto-generated method stub
        for(int i=a;i<=beg;i++)
        {
            Solution.threadArray[i] = i;
        }   
     }
    
   }

   class Task3 extends Thread
   {
    static int a = 0;
    static int beg = 0;
    public void run() 
    {
        // TODO Auto-generated method stub
        for(int i=a;i<=beg;i++)
        {
            Solution.threadArray[i] = i;
        }   
     }
    

   }

   public class Solution 
   {
      public static final int[] threadArray = new int[300];
    
    public static volatile String i = 0+"";

    public boolean test() throws InterruptedException
    {
        Task1 task1 = new Task1();
        Task2 task2 = new Task2();
        Task3 task3 = new Task3();
        Thread task2Thread = new Thread(task2);
        Thread task3Thread = new Thread(task3);
        task1.start();
        task2Thread.start();
        task1.join();
        task2Thread.join();
        task3Thread.start();
        int first = Task1.a+Task2.a;
        int containsSecondThread = Task1.a;
        String oneAndTwo = "";
        String sizeOfTask1 = "";
        for(int i=0;i<first;i++)
        {
            oneAndTwo += threadArray[i]+" ";
        }
        for(int i=0;i<containsSecondThread;i++)
        {
            sizeOfTask1 += threadArray[i]+" ";
        }
        int begOfTask3 = Task3.beg;
        String checkingString = "";
        for(int i=begOfTask3;i<threadArray.length;i++)
        {
            checkingString += i + " ";
        }
        String task3String = "";
        for(int j = begOfTask3;j<threadArray.length;j++)
        {
            task3String += threadArray[j]+" ";
        }
        if((!oneAndTwo.contains(begOfTask3+"") && sizeOfTask1.contains(Task2.beg+"")) || task3String.equals(checkingString))
        {
            return true;
        }
        return false;
    }
    
    public static void main(String[] args) throws InterruptedException 
    {
        Scanner sc= new Scanner(System.in);
        
        Solution solution = new Solution();
        int one = sc.nextInt();
        Task1.a = one;
        Task1.beg = 0;
        int two = sc.nextInt();
        Task2.a = two;
        Task2.beg = one;
        int three = sc.nextInt();
        Task3.a = three;
        Task3.beg = one+two;
        System.out.print(solution.test());
    }
   }

共有2个答案

潘弘壮

2023-03-14

线程1和线程2应该访问threadArray[0...Task1.a Task2 a]。所以我们必须利用我在解决方案类中声明的静态可变变量。

class Task1 extends Thread
{
    static int a=0,beg=0;
    public void run()
    {
        int k=Task1.beg;
        int i1=0;
        while(i1<Task1.a)
        {
            Solution.threadArray[Integer.parseInt(Solution.i)]=k++;
            int a1=Integer.parseInt(Solution.i);
            a1++;i1++;
            Solution.i=a1+"";
            try{
                Thread.sleep(1);
            }
            catch(InterruptedException e){}
        }
    }
}
class Task2 extends Thread
{
    static int a=0,beg=0;
    public void run()
    {
        int y=0;
        int k=Task2.beg;
        while(y<Task2.a)
        {
            Solution.threadArray[Integer.parseInt(Solution.i)]=k++;
            int a1=Integer.parseInt(Solution.i);
            a1++;y++;
            Solution.i=a1+"";
            try{
                Thread.sleep(1);
            }
            catch(InterruptedException e){}
        }
    }
}

前2个线程完成后，Thread3独立工作。

class Task3 extends Thread
{
    static int beg=0,a=0;
    public void run()
    {
        for(int i=Task3.beg;i<Task3.beg+Task3.a;i++)
            {
                Solution.threadArray[i]=i; 
            }
        
    }
}

黄飞翮

2023-03-14

首先，关于您的代码的一些观察:在扩展类< code>Thread的类(即< code>Task1 、< code>Task2和< code>Task3)中不使用静态变量(要理解为什么，请看一下为什么静态变量被认为是邪恶的？):

static int a = 0;
static int beg = 0;

使用非静态的final字段，并通过构造函数初始化它们:

class Task1 extends Thread
{
    private final int begin;
    private final int end;

    Task1(int begin, int end){
        this.begin = begin;
        this.end = end;
    }

     public void run(){
        for(int i=begin; i<= end; i++)
           ....
    }
}

相应地调整main方法：

public static void main(String[] args){
       ...
       Task1 task1 = new Task1(begin, end);
}

然后将与任务相关的对象作为参数传递给test方法：

public boolean test(Task1 task1, Task2 task2, Task3 task3){ 
      ...
}

对于字符串的连接，使用StringBuilder：

StringBuilder oneAndTwo = new StringBuilder();
for(int i=0;i<first;i++)
{
    oneAndTwo.append(threadArray[i]).append(" ");
}

这看起来不对:

    Task1.a = one;
    Task1.beg = 0;

通过查看来自Task1的run方法的循环，这意味着，如果Task1. a不是负数，则Task1不会做任何工作。

要使用线程生成数组的随机值，请执行以下操作：

int[] 线程数组 = 新 int[300];

您可以首先提取一种方法来生成这些随机值，基于公式：

 r.nextInt(high-low) + low;

此公式生成一个介于< code >低和< code >高之间的随机值。

相应地调整任务:

class Task1 extends Thread
{
    private final Random random_values = new Random();
    private final int low;
    private final int high;
    ...
    
    public int generate_random(){
           return r.nextInt(high-low) + low;
    }

    public void run()
    {
        for(....)
        {
            Solution.threadArray[i] = generate_random();
            ...
        }
    }
}

确保将有关要生成的随机值的范围（即，低参数和高参数）的信息传递给线程，以及对将用这些随机值填充的数组的引用（即数组 int[] threadArray）。还要确保在线程之间拆分迭代 int[] 线程数组。因此，每个线程应生成随机值的块。这种分布的一个例子是：

Thread 1 : 0 to 100;
Thread 2 : 100 to 200;
Thread 3 : 200 to 300;

您可以使其更健壮，将数组长度除以线程数，并相应地在线程之间分配工作。

我本可以为您提供整个解决方案，但我觉得如果我给你指示，这样你就可以自己做，那就更好了。

编辑：根据新编辑的问题：

您只需要按照以下方式调整任务类：

class Task1 extends Thread {
    static int a = 0;
    static int beg = 0;

    public void run(){
        for(int i=beg;i < a;i++)
            Solution.threadArray[i] = i;
    }
}

class Task2 extends Thread {
    static int a = 0;
    static int beg = 0;
    
    public void run(){
        for(int i=beg; i< beg + a;i++)
            Solution.threadArray[i] = i;
    }
}

class Task3 extends Thread{
    static int a = 0;
    static int beg = 0;
    public void run(){
        for(int i=beg;i< a + beg;i++)
            Solution.threadArray[i] = i;
    }
}

类似资料：

考虑一个包含任务的队列(task1、task2、task3、task1、task2、task3、...)，如何使用两个线程来删除队列中的任务

案例：考虑到您有一个包含任务的队列(task1、task2、task3、task1、task2、task3、…)，我如何使用两个线程来删除队列中的任务。要求：流量图代码
c++ 类中const成员变量的赋值方法

本文向大家介绍c++ 类中const成员变量的赋值方法，包括了c++ 类中const成员变量的赋值方法的使用技巧和注意事项，需要的朋友参考一下在头文件的类的定义中定义了一个const成员变量c++ 规则： 1、类定义中不能进行初始化，因为头文件中类的定义只是一个声明，并没有分配真正空间，因此变量是不存在的，因此是不能赋值的。 2、const 定义的变量是不能赋值这可如何是好，声明中不能赋值，声
为变量赋值
如何在ComboBox上使用ActionListener为变量赋值

问题内容：我正在使用BlueJ，但遇到了问题。我有一个带有3个选项的组合框。每个选项都是一个字符串。这三个选项是日，周和月。我想做的是，如果选择Day，则变量等于30（双精度），依此类推。有人可以帮我买吗，告诉我如何根据组合框中的所选选项为“ emailvalue”赋予值？编辑：我要添加我的实际程序代码，它是每月的数据计算器。它确实可以编译。这是代码：问题答案： 1）首先，您需要添加一个以
变量赋值如何在JavaScript中起作用？

问题内容：因此，前几天我在玩，目的是确切了解批量分配在JavaScript中的工作方式。首先，我在控制台中尝试了以下示例：结果是“栏”显示在警报中。这很公平，并且实际上只是同一对象的别名。然后我想，如何使这个例子更简单。那几乎是同一回事，不是吗？好吧，这次返回的结果与我从第一个示例的行为所期望的不一样。为什么会这样？注意：可以使用以下代码进一步简化此示例：（我怀疑JavaScrip
在Python中，如何在类方法中访问“静态”类变量

问题内容：如果我有以下python代码：它抱怨如何bar在方法中访问类/静态变量？问题答案：代替bar使用或。分配给将创建一个静态变量，分配给将创建一个实例变量。

如何在Task1、Task2、Task3类run（）方法中为threadArray变量赋值？

共有2个答案

相关问答

相关文章

相关阅读

相关工具

相关文档