Spawning two threads and if any of the threads returns true, let the main thread ignore the other and move on Exact problem statement:

A main thread spawns 2 new threads, the main thread waits on this
threads with these conditions:

if any of the threads returns True, then main thread moves on and prints the thread_id and timestamp of the thread.
if both threads return false, finish execution and don't print anything


My attempt:
public static void main(String[] args) throws InterruptedException, ExecutionException{        
        FutureTask&lt;Boolean&gt; futureTask = new FutureTask&lt;&gt;(() -&gt; {
          System.out.println(&quot;Hello, World 1!&quot;);
          return true;
        });
        FutureTask&lt;Boolean&gt; futureTask2 = new FutureTask&lt;&gt;(() -&gt; {
          System.out.println(&quot;Hello, World 2!&quot;);
          return true;
        });
        
        Thread t1 = new Thread(futureTask);
        Thread t2 = new Thread(futureTask2);
        t1.start();
        t2.start();
        
        // Wait for either to be done.
        while (!futureTask.isDone() &amp;&amp; !futureTask2.isDone());

        if (futureTask.isDone()) {
          if (futureTask.get()) {
            System.out.println(&quot;1 - &quot; + t1.getId() + &quot; &quot; + System.currentTimeMillis());
            return;
          }
        }

        if (futureTask2.isDone()) {
          if (futureTask2.get()) {
            System.out.println(&quot;2 - &quot; + t2.getId() + &quot; &quot; + System.currentTimeMillis());
            return;
          }
        }
    }
}

When I run this a few times, sometimes thread 1 wins, sometimes 2, which seems to make sense to me. Appreciate any room for improvement or advice.
Bug
I'd post this as a comment and a close vote, but you already have two answers.
Your program does not actually fulfill the problem statement.  If one thread quickly returns false and the other has not finished yet (but will return true eventually), your program halts and prints nothing.  But instead, it should wait for the second thread to finish.
Testing
You could have found this yourself with a more robust testing framework.  You should test all of the following situations:

Both return true.  Task 1 returns first.
Both return true.  Task 2 returns first.
Task 1 returns true first and later task 2 would return false.
Task 1 returns true but task 2 returns false later.
Task 2 returns true first and later task 1 would return false.
Task 2 returns true but task 1 returns false later.
Both return false.  Task 1 returns first.
Both return false.  Task 2 returns first.

You might also want to check what happens when a task never returns.  There may be other edge cases as well.
Numbered variables
Variables named 1 and 2 are a potential code smell.  In general when you have this, you should consider if you could actually either name the variables better or switch to a collection (e.g. an array or something that implements the Collection interface).
A side benefit of switching to a collection is that it frees you up in case the requirements change from two to another number.
This is not to say that there are no circumstances under which numbered variables are OK.  Only that when you consider using them, you should consider if they really make sense.
Modularization
To make testing easier, I would move the main code outside of the main method.  So instead of editing the main method for each test, your tests would create the appropriate tasks and pass them to the task runner.  The task runner could then enshrine the logic of

Create threads.
Launch them.
Check if they are finished.
If one is finished, check if its task returned true and produce the correct output.
If both returned false, return.

Note that this will be easier to test if the task runner method returns a string rather than printing output.  You can leave the printing logic in your main method.
Test frameworks
Even better than putting your tests in your main method, put them into some kind of test framework.  E.g. JUnit.  With a testing framework, it is easy to run every test every time.