Parallel Classe

Definição

Fornece suporte para regiões e loops paralelos.Provides support for parallel loops and regions.

public ref class Parallel abstract sealed
public static class Parallel
type Parallel = class
Public Class Parallel
Herança
Parallel

Exemplos

Este exemplo demonstra várias abordagens para implementar um loop paralelo usando construções de várias linguagens.This example demonstrates several approaches to implementing a parallel loop using multiple language constructs.

using System.Threading.Tasks;   
class Test
{
    static int N = 1000;

    static void TestMethod()
    {
        // Using a named method.
        Parallel.For(0, N, Method2);

        // Using an anonymous method.
        Parallel.For(0, N, delegate(int i)
        {
            // Do Work.
        });

        // Using a lambda expression.
        Parallel.For(0, N, i =>
        {
            // Do Work.
        });
    }

    static void Method2(int i)
    {
        // Do work.
    }
}
Imports System.Threading.Tasks

Module Module1

    Sub Main()
        Dim N As Integer = 1000

        ' Using a named method
        Parallel.For(0, N, AddressOf Method2)

        ' Using a lambda expression.
        Parallel.For(0, N, Sub(i)
                               ' Do Work
                           End Sub)
    End Sub

    Sub Method2(ByVal i As Integer)
        ' Do work.
    End Sub

End Module

Comentários

A Parallel classe fornece substituições paralelas de dados baseados em biblioteca para operações comuns, como loops for, para cada loop e execução de um conjunto de instruções.The Parallel class provides library-based data parallel replacements for common operations such as for loops, for each loops, and execution of a set of statements.

Métodos

For(Int32, Int32, Action<Int32,ParallelLoopState>)

Executa um loop for no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a for loop in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

For(Int32, Int32, Action<Int32>)

Executa um loop for no qual as iterações podem ser executadas em paralelo.Executes a for loop in which iterations may run in parallel.

For(Int32, Int32, ParallelOptions, Action<Int32,ParallelLoopState>)

Executa um loop for no qual as iterações podem ser executadas em paralelo, as opções do loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a for loop in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

For(Int32, Int32, ParallelOptions, Action<Int32>)

Executa um loop for em que as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.Executes a for loop in which iterations may run in parallel and loop options can be configured.

For(Int64, Int64, Action<Int64,ParallelLoopState>)

Executa um loop for com índices de 64 bits no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a for loop with 64-bit indexes in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

For(Int64, Int64, Action<Int64>)

Executa um loop for com índices de 64 bits no qual as iterações podem ser executadas em paralelo.Executes a for loop with 64-bit indexes in which iterations may run in parallel.

For(Int64, Int64, ParallelOptions, Action<Int64,ParallelLoopState>)

Executa um loop for com índices de 64 bits no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.Executes a for loop with 64-bit indexes in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

For(Int64, Int64, ParallelOptions, Action<Int64>)

Executa um loop for com índices de 64 bits no qual as iterações podem ser executadas em paralelo e opções de loop podem ser configuradas.Executes a for loop with 64-bit indexes in which iterations may run in parallel and loop options can be configured.

For<TLocal>(Int32, Int32, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa um loop for com os dados locais de thread no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a for loop with thread-local data in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

For<TLocal>(Int32, Int32, ParallelOptions, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa um loop for com os dados locais do thread nos quais iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a for loop with thread-local data in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

For<TLocal>(Int64, Int64, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa um loop for com índices de 64 bits e dados locais de thread no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a for loop with 64-bit indexes and thread-local data in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

For<TLocal>(Int64, Int64, ParallelOptions, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa um loop for com índices de 64 bits e dados locais do thread nos quais iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a for loop with 64-bit indexes and thread-local data in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados de local de thread em um IEnumerable no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com índices de dados de local de thread em um IEnumerable, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados locais de thread e índices de 64 bits em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data and 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados locais do thread em um IEnumerable no qual as iterações podem ser executadas em paralelo, as opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados locais do thread em um OrderablePartitioner<TSource>, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com índices de 64 bits e dados locais do thread em um OrderablePartitioner<TSource>, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes and with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel , loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados de local de thread em um Partitioner, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Executa uma operação foreach (For Each no Visual Basic) com os dados locais do thread em um Partitioner, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)

Executa uma operação foreach (For Each no Visual Basic) com índices de 64 bits em uma IEnumerable na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)

Executa uma operação foreach (For Each no Visual Basic) em uma IEnumerable na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)

Executa uma operação foreach (For Each no Visual Basic) em um IEnumerable no qual as iterações podem ser executadas em paralelo.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel.

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)

Executa uma operação foreach (For Each no Visual Basic) em índices de 64 bits em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)

Executa uma operação foreach (For Each no Visual Basic) em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>)

Executa uma operação foreach (For Each no Visual Basic) em um IEnumerable no qual as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel and loop options can be configured.

ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)

Executa uma operação foreach (For Each no Visual Basic) em um OrderablePartitioner<TSource>, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)

Executa uma operação foreach (For Each no Visual Basic) em um OrderablePartitioner<TSource>, em que iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)

Executa uma operação foreach (For Each no Visual Basic) em um Partitioner, na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(Partitioner<TSource>, Action<TSource>)

Executa uma operação foreach (For Each no Visual Basic) em um Partitioner no qual as iterações podem ser executadas em paralelo.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel.

ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)

Executa uma operação foreach (For Each no Visual Basic) em um Partitioner, em que iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>)

Executa uma operação foreach (For Each no Visual Basic) em um Partitioner no qual as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel and loop options can be configured.

Invoke(Action[])

Executa cada uma das ações fornecidas, possivelmente em paralelo.Executes each of the provided actions, possibly in parallel.

Invoke(ParallelOptions, Action[])

Executa cada uma das ações fornecidas, possivelmente em paralelo, a menos que a operação seja cancelada pelo usuário.Executes each of the provided actions, possibly in parallel, unless the operation is cancelled by the user.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos do Parallel são thread-safe e podem ser usados simultaneamente de vários threads.All public and protected members of Parallel are thread-safe and may be used concurrently from multiple threads.

Confira também