Как я могу присвоить значение переменной threadArray в методе run() класса Task1, Task2, Task3?

Во-первых, некоторые наблюдения относительно вашего кода: вместо использования статических переменных в классах (т. е. Task1, Task2 и Task3), которые расширяют класс Thread (чтобы понять, почему взгляните на Почему статические переменные считаются злом?) :

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

используйте нестатические конечные поля и инициализируйте их через конструктор:

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;

глядя на цикл метода run из Task1, это означает, что если Task1.a не является отрицательным числом, то Task1 не будет выполнять никакой работы.

Чтобы использовать threads для генерации случайных значений массива:

int[] threadArray = new int[300];

вы можете начать с извлечения метода для генерации этих случайных значений на основе формулы:

 r.nextInt(high-low) + low;

эта формула генерирует случайное значение между low и high.

Адаптируйте задачи соответственно:

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();
            ...
        }
    }
}

Обязательно передайте в потоки информацию о диапазоне генерируемых случайных значений (т. е. параметры low и high) и ссылку на массив, который будет заполнен этими случайными значениями (т. е. массив int[] threadArray) . Также убедитесь, что вы разделили итерации int[] threadArray между потоками. Следовательно, каждый поток должен генерировать порцию случайных значений. Примером такого распределения может быть:

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

Вы можете сделать это более надежным и разделить длину массива на количество потоков и соответственно распределить работу между потоками.

Я мог бы предоставить вам полное решение, но я чувствую, что будет лучше, если я дам вам подсказки, чтобы вы могли сделать это самостоятельно.

Обновлено: на основе нового редактирования вашего вопроса:

Вам просто нужно адаптировать классы Task следующим образом:

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;
    }
}

Предполагается, что Thread1 и Thread2 имеют доступ к общему ресурсу в threadArray[0... Task1.a+Task2+a]. Поэтому мы должны использовать статическую переменную volatile, которую я объявил в классе решения.

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){}
        }
    }
}

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; 
            }
        
    }
}