This idea of **asynchronous** code described above is also sometimes called **"concurrency"**. It is different from **"parallelism"**.

**Concurrency** and **parallelism** both relate to "different things happening more or less at the same time".

But the details between *concurrency* and *parallelism* are quite different.

To see the difference, imagine the following story about burgers:

### Concurrent Burgers

			}
			if spec.Parallelism != nil && *spec.Parallelism > maxParallelismForIndexedJob {
				allErrs = append(allErrs, field.Invalid(fldPath.Child("parallelism"), *spec.Parallelism, fmt.Sprintf("must be less than or equal to %d when completion mode is %s", maxParallelismForIndexedJob, batch.IndexedCompletion)))
			}

namespace tensorflow {

// This pass adds scopes to nodes in the _XlaInternalScope attribute to guide
// the later clustering passes.  A major reason to do this is to prevent the
// clustering from losing critical parallelism in the Tensorflow graph, which
// can incur great performance degradation.
//
// This pass must be run before MarkForCompilationPass, as it stores the
// scoping information that MarkForCompilationPass will need to respect for

            // prevent assembly and c compile tasks from running in parallel
            // this is because we don't want the c compile tasks to accidentally use
            // the decorated tool provider we set up for testing the parallelism
            tasks.withType(CCompile) { mustRunAfter tasks.withType(Assemble) }
        """

        when:
        succeeds("assemble", "parallelTask")

        then:

			},
			expectedUsername: "config",
			expectedConfig: kubeschedulerconfig.KubeSchedulerConfiguration{
				TypeMeta: metav1.TypeMeta{
					APIVersion: v1.SchemeGroupVersion.String(),
				},
				Parallelism:           16,
				DelayCacheUntilActive: false,
				DebuggingConfiguration: componentbaseconfig.DebuggingConfiguration{
					EnableProfiling:           true,
					EnableContentionProfiling: true,
				},

	return func(o *schedulerOptions) {
		o.profiles = p
		o.applyDefaultProfile = false
	}
}

// WithParallelism sets the parallelism for all scheduler algorithms. Default is 16.
func WithParallelism(threads int32) Option {
	return func(o *schedulerOptions) {
		o.parallelism = threads
	}
}

// WithPercentageOfNodesToScore sets percentageOfNodesToScore for Scheduler.

            // this is because we don't want the cpp compile tasks to accidentally use 
            // the decorated tool provider we set up for testing the parallelism
            tasks.withType(CppCompile) { mustRunAfter tasks.withType(WindowsResourceCompile) }
        """

        when:
        succeeds("assemble", "parallelTask")

        then:

func SetDefaults_KubeSchedulerConfiguration(obj *configv1.KubeSchedulerConfiguration) {
	logger := klog.TODO() // called by generated code that doesn't pass a logger. See #115724
	if obj.Parallelism == nil {
		obj.Parallelism = ptr.To[int32](16)
	}

	if len(obj.Profiles) == 0 {
		obj.Profiles = append(obj.Profiles, configv1.KubeSchedulerProfile{})
	}

	}

	return e
}

func (e *executor) ActiveRequests() uint64 {
	return e.activeRequests.Load()
}

// NewGroup creates a new group of tasks that can be managed collectively.
// Parallelism is limited by the global maxConcurrency of the executor.
func (e *executor) NewGroup() *execGroup {
	return &execGroup{
		e:   e,
		sem: semaphore.NewWeighted(int64(maxConcurrencyPerForward)),
	}
}

        if (!gradlePropertiesFile.exists()) {
            throw new IllegalArgumentException("Every test project needs to provide a gradle.properties file with memory and parallelism settings")
        }
        def gradleProperties = new Properties()
        gradlePropertiesFile.withInputStream {gradleProperties.load(it) }