Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# HelloWorldWorkflowParallel Applicazione
<a name="getting-started-example-helloworldworkflowparallel"></a>

Le versioni precedenti di Hello World\$1 tutti utilizzare un flusso di lavoro lineare topologia. Tuttavia, Amazon SWF non si limita alle topologie lineari. L' HelloWorldWorkflowParallel applicazione è una versione modificata HelloWorldWorkflow che utilizza una topologia parallela, come illustrato nella figura seguente.

![\[HelloWorldWorkflowParallel topologia del flusso di lavoro\]](http://docs.aws.amazon.com/it_it/amazonswf/latest/awsflowguide/images/helloworld_parallel_topology.png)


Con HelloWorldWorkflowParallel, `getName` e `getGreeting` corri in parallelo e ognuno restituisce una parte del saluto. `say`quindi unisce le due stringhe in un messaggio di saluto e lo stampa sulla console.

Per implementare l'applicazione, crea una copia di HelloWorld. HelloWorldWorkflow pacchetto nella directory del progetto e chiamalo HelloWorld. HelloWorldWorkflowParallel. Le sezioni seguenti descrivono come modificare il HelloWorldWorkflow codice originale per l'esecuzione `getName` e `getGreeting` in parallelo.

## HelloWorldWorkflowParallel Attività: Lavoratore
<a name="getting-started-example-helloworldworkflowparallel.activities"></a>

L'interfaccia HelloWorldWorkflowParallel delle attività è implementata in`GreeterActivities`, come illustrato nell'esempio seguente.

```
import com.amazonaws.services.simpleworkflow.flow.annotations.Activities;
import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions;

@Activities(version="5.0")
@ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300,
                             defaultTaskStartToCloseTimeoutSeconds = 10)
public interface GreeterActivities {
   public String getName();
   public String getGreeting();
   public void say(String greeting, String name);
}
```

L'interfaccia è simile a HelloWorldWorkflow, con le seguenti eccezioni:
+ `getGreeting` non accetta alcun input, ma restituisce semplicemente una stringa di formula di apertura.
+ `say` accetta due stringhe di input, la formula di apertura e il nome.
+ L'interfaccia ha un nuovo numero di versione, necessario ogni volta che modifichi un'interfaccia registrata.

HelloWorldWorkflowParallel implementa le attività in`GreeterActivitiesImpl`, come segue:

```
public class GreeterActivitiesImpl implements GreeterActivities {

   @Override
   public String getName() {
      return "World!";
   }

   @Override
   public String getGreeting() {
      return "Hello ";
   }

   @Override
   public void say(String greeting, String name) {
      System.out.println(greeting + name);
   }
}
```

Ora `getName` e `getGreeting` restituiscono semplicemente metà della stringa di formula di apertura. `say` concatena le due parti per generare la frase completa e la stampa sulla console.

## HelloWorldWorkflowParallel Workflow Worker
<a name="getting-started-example-helloworldworkflowparallel-worker"></a>

L'interfaccia del HelloWorldWorkflowParallel flusso di lavoro è implementata in`GreeterWorkflow`, come segue:

```
import com.amazonaws.services.simpleworkflow.flow.annotations.Execute;
import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow;
import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions;

@Workflow
@WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600)
public interface GreeterWorkflow {

   @Execute(version = "5.0")
   public void greet();
}
```

La classe è identica alla HelloWorldWorkflow versione, tranne per il fatto che il numero di versione è stato modificato per corrispondere all'operatore delle attività.

Il flusso di lavoro è implementato in `GreeterWorkflowImpl`, come mostrato di seguito:

```
import com.amazonaws.services.simpleworkflow.flow.core.Promise;

public class GreeterWorkflowImpl implements GreeterWorkflow {
   private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl();

   public void greet() {
      Promise<String> name = operations.getName();
      Promise<String> greeting = operations.getGreeting();
      operations.say(greeting, name);
   }
}
```

A prima vista, questa implementazione sembra molto simile alle HelloWorldWorkflow tre attività eseguite in sequenza dai metodi client. Tuttavia, ciò non avviene per le attività.
+ HelloWorldWorkflow passato `name` a. `getGreeting` Poiché `name` era un oggetto `Promise<T>`, `getGreeting` ha posticipato l'esecuzione dell'attività fino al completamento di `getName` e le due attività sono state eseguite in sequenza.
+ HelloWorldWorkflowParallel non trasmette alcun input `getName` o`getGreeting`. Nessuno dei due metodi posticipa l'esecuzione e i metodi di attività associati sono eseguiti immediatamente e in parallelo.

L'attività `say` accetta `greeting` e `name` come parametri di input. Poiché sono oggetti `Promise<T>`, `say` posticipa l'esecuzione fino al completamento di entrambe le attività e quindi costruisce e stampa la formula di apertura.

Si noti che HelloWorldWorkflowParallel non utilizza alcun codice di modellazione speciale per definire la topologia del flusso di lavoro. Lo fa implicitamente utilizzando il controllo di flusso Java standard e sfruttando le proprietà degli oggetti. `Promise<T>` AWS Flow Framework per le applicazioni Java è possibile implementare anche topologie complesse semplicemente utilizzando `Promise<T>` oggetti insieme ai costrutti di flusso di controllo Java convenzionali.

## HelloWorldWorkflowParallel Workflow e attività Host and Starter
<a name="HelloWorldWorkflowParallel-workflow-activities-host-starter"></a>

HelloWorldWorkflowParallel implementa `GreeterWorker` come classe host per le implementazioni del flusso di lavoro e delle attività. È identico all' HelloWorldWorkflow implementazione tranne per il `taskListToPoll` nome, che è impostato su "»HelloWorldParallelList.

`HelloWorldWorkflowParallel`implementa il workflow starter in `GreeterMain` ed è identico all' HelloWorldWorkflow implementazione.

Per eseguire il flusso di lavoro, esegui `GreeterWorker` e `GreeterMain` esattamente come con `HelloWorldWorkflow`.