Semaphore Question: Accessing Thread Variable From A Parallel Thread

I'm trying to get understand Semaphores in Java and I want to use parallel threads to simultaneously generate numbers in an array and perform operations with that data without altering the array itself in order to avoid race conditions. Generating the numbers in the first thread is simple enough and getting the data post generation also wouldn't be too hard if the program worked serially. However, I don't quite understand how to access the array from the other thread while it is being generated. I know that Semaphores are intended to be used to control access to a shared data structure, similar to mutex locks, what's unclear to me is how to declare that (in this case an array) in a legal way.

Here is a basic example:

import java.util.concurrent.Semaphore;
import java.util.Random;
public class Main {
static Semaphore semaphore = new Semaphore(2);
static class Thread1 extends Thread {
private int[] randArray = new int[50];
public void run() {
try {
Random rng = new Random();
semaphore.acquire();
try {
for (int i = 0; i < 50; i++) {
randArray[i] = rng.nextInt() % 100;
System.out.println("Random number " + i + " : " + randArray[i]);
Thread.sleep(2000);
}
} finally {
semaphore.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Thread2 extends Thread {
public void run() {
try {
semaphore.acquire();
try {
for (int i = 0; i < 50; i++) {
// calculate something using array generated in Thread1
Thread.sleep(2000);
}
} finally {
semaphore.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
t1.start();
Thread2 t2 = new Thread2();
t2.start();
}
}

Create the semaphore empty.
Start both threads.
Every time Thread1 loads an array index, post a semaphore unit.
In Thread 2, wait on the semahore in the loop before processing an index.

Get rid of the Sleep calls.

Well, first of all you have no shared data structures here, the array belongs to Thread-1 and that's it.

Second - semaphores do not fit well for this use case. If I understood correctly you want 1 by 1 processing as soon as the element is generated. Semaphores could be used like in your code, but you would be relying on pure luck, that Thread-1 always does his thing and Thread-2 starts right after - not gonna happen in real life. And that's just flow of the program, memory consistency errors aside. This could be rewritten to use semaphores for each element, but that's just to much mess in my opinion.

Semaphores are basically like stores in modern COVID-19 times - there can be only 5 people in the store at a time. When a person walks in it's like semaphore.acquire(), and when a person walks out - semaphore.release(). If someone wants to enter and there is not enough space in the store - he waits for the next person to leave (semaphore.acquire() waits until semaphore.release()).

Basically, you could write this program using atomic classes (like AtomicInteger), locks or even semaphores if you were really stubborn, and it would appear to work (and in most cases it would), but it would have subtle errors related to java memory model (Thread-1 writing and Thread-2 not seeing the changes), unless you knew what you are doing. I suggest using some structure from java.util.concurrent - like AtomicIntegerArray.