One of the important aspects you need to keep in mind is that Swing is not thread safe, this means you should not update the UI or update any value that the UI is reliant on from outside of the context Event Dispatching Thread.

There are a number of ways you deal with this. SwingUtilities.invokeLater, but you really should only use it if the number of times it would be called are small or the time between them is relatively larger (seconds). The main reason for this, is it's very easy to overload the EDT, which can cause the UI to "stall".

Another approach is to use Swing Timer, but this is really only useful if you want to update the UI on a regular based (like animation).

Another approach is to use a SwingWorker. This is a "fancy" wrapper around a Executor which allows you to perform work on a background thread and then publish the results to the EDT which can then safely be processed for the UI.

But why do this? Well, one of things that SwingWorker does is, if your Thread is generating a lot of data in a small amount of time, it will squeeze a number of results into a List and reduce the number of calls made back to the UI, helping maintain some level of performance.

However, in your case, it's probably just a really nice exercise, as you are creating a single thread/worker to do a single job and not getting a single worker/thread to do all the jobs.

In that case, I might consider using a Swing Timer to probe a model of the data instead of having the Thread/worker try and update the UI itself, this way you gain control over the number of updates which are occurring to the UI.

There are pros and cons to all these and you will need to investigate which one(s) work best for your particular scenario

SwingWorker example

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingWorker;
public class GUI {
public static void main(String[] args) {
new GUI();
}
public GUI() {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
JFrame frame = new JFrame();
frame.add(new TestPane(10));
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
});
}
public static interface Consumer {
void setData(int value);
}
public static class WorkerTask extends SwingWorker<Void, Integer> {
private static Lock taskLock = new ReentrantLock();
private Random rand = new Random();
private static int y;
// I'd prefer this was a model object passed into the worker
static volatile ArrayList<Integer> finallist = new ArrayList<>();
private Consumer consumer;
public WorkerTask(Consumer consumer) {
this.consumer = consumer;
}
private int generatePoint() {
taskLock.lock();
int copy = 0;
try {
copy = rand.nextInt(200);
y = copy;
// Array list isn't thread safe ;)
finallist.add(copy);
} finally {
taskLock.unlock();
}
return copy;
}
@Override
protected Void doInBackground() throws Exception {
// And a random delay
// You should now be able to see the text change
Thread.sleep(rand.nextInt(1000));
publish(generatePoint());
return null;
}
@Override
protected void process(List<Integer> chunks) {
if (chunks.isEmpty()) {
return;
}
int last = chunks.get(chunks.size() - 1);
consumer.setData(last);
}
}
public class TestPane extends JPanel {
private boolean check;
private int y;
private CountDownLatch latch;
public TestPane(int count) {
latch = new CountDownLatch(count);
for (int i = 0; i < count; i++) {
WorkerTask task = new WorkerTask(new Consumer() {
@Override
public void setData(int value) {
// This is on the EDT, so it's safe to update the UI with
TestPane.this.setData(value);
}
});
task.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
WorkerTask task = (WorkerTask) evt.getSource();
if (task.getState() == SwingWorker.StateValue.DONE) {
latch.countDown();
}
}
});
task.execute();
}
// This only matters if you want the result to be delivered
// on the EDT.  You could get away with using a Thread otherwise
SwingWorker waiter = new SwingWorker<Void, List<Integer>>() {
@Override
protected Void doInBackground() throws Exception {
System.out.println("Waiting");
try {
latch.await();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("All done here, thanks");
publish(WorkerTask.finallist);
return null;
}
@Override
protected void process(List<List<Integer>> chunks) {
if (chunks.isEmpty()) {
return;
}
List<Integer> values = chunks.get(chunks.size() - 1);
completed(values);
}
};
waiter.execute();
}
@Override
public Dimension getPreferredSize() {
return new Dimension(200, 200);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
if (check) {
g2d.drawString("here", 100, y);
}
g2d.dispose();
}
void setData(int y) {
check = true;
System.out.println(y);
this.y = y;
repaint();
}
protected void completed(List<Integer> values) {
// And executed on the EDT
System.out.println("All your value belong to us");
for (int value : WorkerTask.finallist) {
System.out.println(">> " + value);
}
}
}
}

I recommend looking at:

• Concurrency in Swing
• Worker Threads and SwingWorker
• Executors if you're really interested in understanding how SwingWorkers work

Before I explain the solution to your problem, I would like to point out some issues with your code.

1. You only do one operation in each thread, and it does not seem to be a long-running one (The run method is only called once, in case you don't know). I'm not sure if you just put it for the sake of having it as a placeholder, or if it's actually part of your code. But if you don't have a long running operation, is it worth doing it in a separate thread? Think about the trade-offs.
2. No need to join the threads, as they will probably finish almost immediately in your code.

Now to the solution, this documentation explains that Swing is not thread-safe, but there is a way to make changes on the GUI. You should use this method to make any changes: SwingUtilities.invokeLater(..).

public static void main(String[] args) throws InterruptedException {
GUI g = new GUI();
g.setVisible(true);
Scanner input = new Scanner(System.in);
System.out.println("Please input the number of Threads you want to create: ");
int n = input.nextInt();
System.out.println("You selected " + n + " Threads");
Thread[] threads = new Thread[n];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Task(g);
threads[i].start();
}
for (int j = 0; j < n; j++) {
threads[j].join();
}
for(Integer s: Task.finallist) {
if(s > 30) {
// here you submit a Runnable to the event-dispatcher thread in which the Swing Application runs
SwingUtilities.invokeLater(() -> {
g.setData(s);       
});
}
}
}

The same should also be done in your run method:

public void run() {
generatePoint();
int copy = y;
finallist.add(copy);
SwingUtilities.invokeLater(() -> {
g.setData(copy);       
});
}