Ist die Thread.start () -Methode für einen neuen Thread sofort wieder auf den aktuellen Thread?

Pra bhashwara Felder:

Ich lese das Buch Core - Java von Cay S. Horstmann. Ich bin mit diesem Code in dem Abschnitt Gleichzeitigkeit verwechselt. Wir bauen einen neuen Thread und geben unsere RunnableAufgabe, ich bis das verstehen werden. Der Teil, der verwirrt mich das heißt, wir nennen start()Methode auf diese neuen Threads auf nach dem anderen. Meine Frage ist , dass , wenn tut den ersten Aufruf an die start()Methode kehrt zum main()Verfahren. Ist es nach dem neuen Thread hat seine Aufgabe beendet hat oder es gibt , während die neuen Thread die Aufgabe ausgeführt wird ?

import java.util.Arrays;

public class Main   {
  public static final int DELAY = 10;
  public static final int STEPS = 100;
  public static final double MAX_AMOUNT = 1000;

  public static void main(String[] args)  {

    var bank = new Bank(4, 100000);
    Runnable task1 = () -> {
    try {

    for (int i = 0; i < STEPS; i++){

      double amount = MAX_AMOUNT * Math.random();
      bank.transfer(0, 1, amount);
      Thread.sleep((int) (DELAY * Math.random()));

    }

    }catch (InterruptedException e) {
    }

    };

    Runnable task2 = () ->{
    try{

    for (int i = 0; i < STEPS; i++){

      double amount = MAX_AMOUNT * Math.random();
      bank.transfer(2, 3, amount);
      Thread.sleep((int) (DELAY * Math.random()));

    }

    }
    catch (InterruptedException e){
    }

    };

    new Thread(task1).start();
    new Thread(task2).start();

  }

}

class Bank{

  private final double[] accounts;

  /**
   * Constructs the bank.
   * @param n the number of accounts
   * @param initialBalance the initial balance for each account
   *
   **/

  public Bank(int n, double initialBalance){

    accounts = new double[n];
    Arrays.fill(accounts, initialBalance);

   }

   /**
    * Transfers money from one account to another.
    * @param from the account to transfer from
    * @param to the account to transfer to 27
    * @param amount the amount to transfer 28
    **/

   public void transfer(int from, int to, double amount){

     if (accounts[from] < amount) return;
     System.out.print(Thread.currentThread());
     accounts[from] -= amount;
     System.out.printf(" %10.2f from %d to %d", amount, from, to);
     accounts[to] += amount;
     System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());

   }
   /**
    * Gets the sum of all account balances.
    * @return the total balance 42
    **/

   public double getTotalBalance(){

     double sum = 0;
     for (double a : accounts)
       sum += a;
     return sum;

   }

   /**
    * Gets the number of accounts in the bank.
    * * @return the number of accounts 56
    **/

   public int size(){

     return accounts.length;

   }

}

Dave Der Däne:

Die Start-Methode kehrt sofort zurück und der Haupt-Thread läuft weiter.

Diesen Vorgang können Sie mit diesem kleinen Proggy sehen:

import java.time.Duration;
import java.time.ZonedDateTime;

public class Runner {

    public static void main(final String[] args) throws Exception {

        final Runnable runner = () -> {
            System.out.println(ZonedDateTime.now() + " " + Thread.currentThread().getName() + " Running...");

            sleep(Duration.ofSeconds(9));

            System.out.println(ZonedDateTime.now() + " " + Thread.currentThread().getName() + " Done.");
        };

        System    .out.println(ZonedDateTime.now() + " " + Thread.currentThread().getName() + " starting Thread 1...");
        new Thread(runner).start();

        System    .out.println(ZonedDateTime.now() + " " + Thread.currentThread().getName() + " starting Thread 2...");
        new Thread(runner).start();

        sleep(Duration.ofSeconds(3));

        System    .out.println(ZonedDateTime.now() + " " + Thread.currentThread().getName() + " done.");
    }

    private static void sleep(final Duration duration) {
        try {
            Thread.sleep(duration.toMillis());
        }
        catch (final InterruptedException e) {}
    }
}