Потоки для методов по нажатию кнопки

Question

Я вызываю несколько методов одним нажатием кнопки.

functionA ()

functionB ()

functionC ()

Все три функции независимы друг от друга и для их выполнения требуется много времени. Я проверил и обнаружил, что благодаря многопоточности я могу запустить все три вместе, что сэкономит время выполнения.

Поскольку я новичок в концепции многопоточности, кто-нибудь может подсказать мне самый простой способ, которым я могу выполнить многопоточность в сценарии или другим способом, который будет полезен в этом сценарии.

EDIT

Еще одна проблема в той же функции:

Я связываю 5 видов сетки после выполнения трех функций. Как это

            gv1.DataSource = GetData("Mill");
            gv1.DataBind();

            gv2.DataSource = GetData("Factory");
            gv2.DataBind();

            gv3.DataSource = GetData("Garage");
            gv3.DataBind();

            gv4.DataSource = GetData("Master");
            gv4.DataBind();

Все они используют один и тот же метод для получения результата, а также они загружают время. Можно ли как-нибудь запустить их параллельно? Я боюсь, потому что они используют один и тот же метод для получения данных. Можно ли сделать для них потоки. Как?

Answer 1

Я не уверен, как Parallel.Invoke () решает, что выполнять параллельно, но если вы хотите гарантировать, что они будут выполняться параллельно, используйте потоки:

var t1 = new Thread(MySlowFunction);
t1.IsBackground = true;
t1.Start();

var t2 = new Thread(MySlowFunction);
t2.IsBackground = true;
t2.Start();

# To resync after completion:
t1.Join();
t2.Join();

Или, что еще лучше, используйте ThreadPool:

  ThreadPool.QueueUserWorkItem(MyWork);

Не забудьте обработать исключения из потоков.

Answer 2

Вот пример, который будет выполнять 4 задачи параллельно:

public partial class _Default : System.Web.UI.Page
{
    public class MyViewModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    protected void Page_Load(object sender, EventArgs e)
    {

    }

    protected void BtnBindClick(object sender, EventArgs e)
    {
        // we define the input for the tasks: each element consists
        // of the grid we are willing to bind the results at the end and
        // some optional parameter we want to pass to the GetData function
        var inputs = new[] 
        { 
            new { Grid = gv1, Input = "Mill" }, 
            new { Grid = gv2, Input = "Factory" }, 
            new { Grid = gv3, Input = "Garage" }, 
            new { Grid = gv4, Input = "Master" }, 
        };

        // define the tasks we want to execute in parallel
        var tasks = inputs
            .Select(x => Task.Factory.StartNew(
                () => new { Grid = x.Grid, Output = GetData(x.Input) })
            )
            .ToArray();

        // define a task which will be executed once all tasks have finished
        var finalTask = Task.Factory.ContinueWhenAll(tasks, x => x);

        // wait for the final task
        finalTask.Wait();

        // consume the results
        foreach (var item in finalTask.Result)
        {
            if (item.Exception == null)
            {
                // if no exception was thrown for this task we could bind the results
                item.Result.Grid.DataSource = item.Result.Output;
                item.Result.Grid.DataBind();
            }
        }
    }

    private MyViewModel[] GetData(string input)
    {
        // Simulate slowness
        Thread.Sleep(1000);
        return Enumerable.Range(1, 5).Select(x => new MyViewModel
        {
            Id = x,
            Name = input
        }).ToArray();
    }
}

Answer 3

Попробуйте использовать пространство имен System.Threading.Tasks

Что-то вроде

var task1 = Task.Factory.StartNew(() => DoA());
var task2 = Task.Factory.StartNew(() => DoB());
var task3 = Task.Factory.StartNew(() => DoC());
Task.WaitAll(task1, task2, task3);

http://www.codethinked.com/net-40-and-systemthreadingtasks

Answer 4

Самый простой ответ - использовать MSDN: Parallel.Invoke () .

Также следует учитывать: Асинхронные страницы .