Então você vai no balcão, para a tarefa inicial que agora está finalizada, pega os hambúrgueres, e leva para a mesa. Isso finaliza esse passo / tarefa da interação com o balcão. Agora é criada uma nova tarefa, "comer hambúrgueres", mas a tarefa anterior, "pegar os hambúrgueres" já está finalizada.

### Hambúrgueres paralelos

Você vai com seu _crush_ :heart_eyes: em uma lanchonete paralela.

Se llama "asíncrono" porque el sistema / programa no tiene que estar "sincronizado" con la tarea lenta, esperando el momento exacto en que finaliza la tarea, sin hacer nada, para poder recoger el resultado de la tarea y continuar el trabajo.

        Task f2 = task("f2", dependsOn: [dep])

        //2 finalized tasks
        Task finalized1 = task("finalized1", finalizedBy: [f1, f2])
        Task finalized2 = task("finalized2", finalizedBy: [f1, f2])

        //tasks that depends on finalized, we will execute them
        Task df1 = task("df1", dependsOn: [finalized1])
        Task df2 = task("df2", dependsOn: [finalized2])

        when:

        }
        2.times {
            fails 'entryPoint', '-PentryPoint.broken'
            result.assertTaskOrder ':entryPoint', any(':finalized1', ':finalized2'), ':finalizer'
        }
        2.times {
            fails 'entryPoint', '-Pfinalized1.broken', '--continue' // add --continue so that finalized2 always runs

        TaskInternal finalizerA = createTask("finalizerA", project, Async)
        TaskInternal finalizerB = createTask("finalizerB", project, Async)
        TaskInternal finalizerDepDep = task("finalizerDepDep", type: Async, finalizedBy: [finalizerA, finalizerB])
        TaskInternal finalizerDep = task("finalizerDep", type: Async, dependsOn: [finalizerDepDep])
        relationships(finalizerA, dependsOn: [finalizerDep])

	if runtime.Compiler == "gccgo" {
		return
	}
	const N = 100
	finalized := make(chan int32, N)
	for i := 0; i < N; i++ {
		x := new(int32) // subject to tiny alloc
		*x = int32(i)
		// the closure must be big enough to be combined
		runtime.SetFinalizer(x, func(p *int32) {
			finalized <- *p
		})
	}
	runtime.GC()
	count := 0
	done := make([]bool, N)

                if (!finalizedNodesToBlockOn.isEmpty()) {
                    // This member is finalized and there are some finalized nodes that are not members. Wait for those nodes
                    blockingNodesBuilder.put(member, waitForFinalizers);
                } else {
                    // All finalized nodes are also members. Block until some other finalized node is started

        def rule1 = rule("path", ModelNode.State.Finalized)
        def rule2 = rule(Long, ModelNode.State.Finalized)
        def rule3 = rule("path", ModelNode.State.Finalized)
        def rule4 = rule(Long, ModelNode.State.Finalized)
        def rule5 = rule(Long, ModelNode.State.Finalized)
        def rule6 = rule("path", ModelNode.State.Finalized)

        given:
        bindings.add(rule1)

     *
     * @param action The action to execute for each element when finalized.
     */
    void whenElementFinalized(Action<? super T> action);

    /**
     * Registers an action to execute when an element of the given type is finalized. The action is only executed for those elements that are required. Fails if any matching element has already been finalized.
     *
     * @param type The type of element to select.

        0 * configure._
        0 * finalized._

        then:
        1 * finalized.execute(binary1)
        1 * finalized.execute(binary2)
        0 * known._
        0 * configure._
        0 * finalized._
    }

    def "runs actions on element of given type when collection is realized"() {
        def known = Mock(Action)
        def configure = Mock(Action)
        def finalized = Mock(Action)