Problem with objects in java threads

The first thing you have to understand is that everything that is in threads can be executed at any time, and the fact of putting synchronized is equivalent to creating a bottleneck that is not really what you want in this case for the calculations but for data reading.

First we abstract the functionality of asking for numbers and returning a list, we will lose a bit of performance, but we will gain that your code is more reusable and easier to maintain.

package es.stackoverflow.com.questions488069;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class LeerNumeros {

    
    public List<Integer> lee(Scanner sc) {
        int num;
        List<Integer> lista = new ArrayList<>(4);
        for (int i = 0; i < 4; i++) {
            System.out.println("Dame un numero: " + i + ":");
            num = sc.nextInt();
            lista.add(num);
            System.out.println();
        }
        return lista;
    }

}

Now we will use the threads to process the primes and non-primes in parallel, so we will rename your class as ExtractorDePrimos:

package es.stackoverflow.com.questions488069;

import java.util.ArrayList;
import java.util.List;

public class ExtractorDePrimos implements Runnable {

    final List<Integer> lista;

    public ExtractorDePrimos(List<Integer> lista) {
        this.lista = lista;
    }

    public void esprimo() {

        ArrayList<Integer> lista_Noprimos = new ArrayList<>(4);
        ArrayList<Integer> lista_primos = new ArrayList<>(4);

        for (int i = 0; i < lista.size(); i++) {
            int num = lista.get(i);

            for (int x = 2; x < num / 2; x++) {
                // Si es divisible por cualquiera de estos números, no
                // es primo
                if (num % x == 0) {
                    lista_Noprimos.add(num);
                    break;
                } //sino, es primo 
                else {
                    lista_primos.add(num);
                    break;
                }

            }

        }

        System.out.println("Esta es la lista de primos " + lista_primos + " esta en la lista de los No primos" + lista_Noprimos + " del hilo " + Thread.currentThread().getName());
    }

    @Override
    public void run() {
        System.out.println("Arrancando hilo: " + Thread.currentThread().getName());
        esprimo();

        System.out.println("El hilo ha terminado");
    }
}

As you will see, I reuse many of your ideas, such as:

• each thread can be created with the list of numbers it is going to work with
• each thread says its name when it starts running

Finally the main class to call everything remains as

package es.stackoverflow.com.questions488069;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main_Actividad01 {

    public static void main(String[] args) {

        List<Integer> lista_primos = new ArrayList<Integer>();
        List<Integer> lista_Noprimos = new ArrayList<Integer>();
        Scanner sc = new Scanner(System.in);

        ExtractorDePrimos lista_primos1 = new ExtractorDePrimos(new LeerNumeros().lee(sc));
        Thread t1 = new Thread(lista_primos1, " Hilo 1 ");
        ExtractorDePrimos lista_Noprimos1 = new ExtractorDePrimos(new LeerNumeros().lee(sc));
        sc.close();
        Thread t2 = new Thread(lista_Noprimos1, " Hilo 2 ");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t1.start();
        t2.start();

    }
}

It's important for you to know that threads don't necessarily end up in the order you created them, (and in fact that's why I print their name along with the results) so you might get output like the following.

Dame un numero: 0:
13

Dame un numero: 1:
53

Dame un numero: 2:
42

Dame un numero: 3:
31

Dame un numero: 0:
33

Dame un numero: 1:
57

Dame un numero: 2:
75

Dame un numero: 3:
23

Arrancando hilo:  Hilo 1 
Arrancando hilo:  Hilo 2 
Esta es la lista de primos [33, 57, 75, 23] esta en la lista de los No primos[] del hilo Hilo 2 
El hilo ha terminado
Esta es la lista de primos [13, 53, 31] esta en la lista de los No primos[42] del hilo Hilo 1 
El hilo ha terminado

In this run, if you notice, the calculations have been done independently, and thread 2 finished before thread one.

Although your example works, the code is very educational and seems to be written in your grandparents' time, since the already obsolete Java 8, new APIs have been added that allow us to do this code less in the object-oriented paradigm and a little more in the object-oriented paradigm. functional.

Since the order doesn't really matter to you, you can also do the calculation of esprimo in parallel with the use of the Stream API as follows:

lista.stream().parallel().forEach(num->{
        for (int x = 2; x < num / 2; x++) {
            // Si es divisible por cualquiera de estos números, no
            // es primo
            if (num % x == 0) {
                lista_Noprimos.add(num);
                break;
            } //sino, es primo 
            else {
                lista_primos.add(num);
                break;
            }

        }
    });

note that .parallel()by itself it takes care of creating as many Threadsas possible according to the limitations of your system for the code you pass to it.

the call to forEach()is equivalent to an improved for , which internally uses an iterator instead of indices to traverse the list, and the parameter it receives is neither more nor less than a lambda function , which, as you can guess, allows us to greatly reduce the code that it would have been done in an anonymous inner class.

The code looks better now, but it still has a lot of steps to be educational, and we're allocating an array the size of 4 integers for each list. We can modify it to use collectors and that alone in a parallel way classify the numbers

public void esprimo() {

    Map<Boolean, List<Integer>> primosyNoPrimos = lista.stream().parallel().collect(Collectors.partitioningBy(num -> {
        for (int x = 2; x < num / 2; x++) {
            // Si es divisible por cualquiera de estos números, no
            // es primo
            return num % x != 0; //sino, es primo

        }
        System.err.println("El número no es positivo, no se trata de un primo a menos que se trate de Optimus Prime xD");
        return false;
    }));

    System.out.println("Esta es la lista de primos " + primosyNoPrimos.get(true) + " esta en la lista de los No primos " + primosyNoPrimos.get(false) + " del hilo " + Thread.currentThread().getName());
}

Now assuming he's a fan of the functional paradigm you could reduce your method to:

public void esprimo() {

    Map<Boolean, List<Integer>> primosyNoPrimos = lista
            .stream()
            .parallel()
            .collect(
                    Collectors.partitioningBy(num -> IntStream.range(2, num / 2)
                    .mapToObj(x -> num % x != 0)
                    .findFirst()
                    .orElse(false))
            );

    System.out.println("Esta es la lista de primos " + primosyNoPrimos.get(true) + " esta en la lista de los No primos " + primosyNoPrimos.get(false) + " del hilo " + Thread.currentThread().getName());
}

Although it is arranged very nicely, it only has two lines. To understand it, it is only necessary to observe that IntStream is a Stream but optimized for data of int types, and that the range method tries to generate numbers in a sequence from the initial value to the final value, then it simply gives us if for the given index the number in question is prime or not, and when chaining the method findFirst, the API internally optimizes the calls so that we don't have to generate the entire range that we initially specified for the IntStream, but only until the condition is met. The last thing to note is that find first returns a semi-monad called Optional, although if you don't know how to use it you can generate NPE (no, it doesn't read nepe, that is how the NullPointerException is colloquially known), also when it is used intelligently as here it gives us values ​​for the cases not contemplated, that is, for the cases in which it has not been marked as prime by the calculation, it is in charge of marking it as non-prime, and with that you save yourself from dealing with not-so-common types of numbers such as imaginary ones, negative ones, and other rare conditions that could take you out of the Z ⁺ space (read this final statement in a bombastic way).

Some time ago I also created an article on how to generate series from a subset such as in this case the primes, and that you can find on my site with an explanation of some more things about the use of lambdas to make generators .