активация темы C #

Question

у меня есть этот код в C #:

Thread t1 = new Thread(functionsActivations(3, 4000, 0, 4));
Thread t2 = new Thread(functionsActivations(3, 4000, 5, 9));
t1.start();
t2.Start();
Thread t3 = new Thread(functionsActivations(4, 4000, 0, 4));
Thread t4 = new Thread(functionsActivations(4, 4000, 5, 9));

Это не работает. Как я могу сказать, чтобы вызвать метод, который я дал? Во-вторых, я хочу, чтобы t3 и t4 были активированы после окончания работы t1 и t2. Как я могу это сделать? В-третьих, я хочу, чтобы t1 и t2 не блокировались (так что t2 не пришлось бы ждать, пока t1 не закончится). Что я сделал правильно?

Answer 1

«Это не работает» не очень четкий набор симптомов. Что вы наблюдаете?

РЕДАКТИРОВАТЬ: Хорошо, теперь, когда вы сказали, что ошибка компилятора, диагностировать намного проще. В настоящее время вы вызываете метод и пытаетесь использовать результат в качестве задачи для выполнения потока. Предполагая, что вы на самом деле хотите выполнить этот метод при запуске потока, вам нужно что-то вроде этого:

C # 2:

Thread t1 = new Thread(delegate() { functionsActivations(3, 4000, 0, 4); });

C # 3:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4));

Альтернативой наличию лямбда-выражений повсеместно было бы написать служебный метод:

private static Action DeferFunctionActivations(int a, int b, int c, int d)
{
    return () => functionsActivations(a, b, d, d);
}

Тогда вы можете использовать:

Thread t1 = new Thread(DeferFunctionActivations(3, 4000, 0, 4));

и т.д.

Для остальной части поста я приму C # 3.

Кроме того, t1.start() должно быть t1.Start() - C # чувствителен к регистру.

Чтобы ответить на ваш последний вопрос, t1 и t2 в настоящее время независимы - они не будут блокировать друг друга, если у вас не будет синхронизации где-то в коде, который они выполняют.

Если вы хотите, чтобы t3 и t4 запускались только после окончания t1 и t2, вы можете использовать Thread.Join:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4));
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9));
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4));
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9));
t3.Start();
t4.Start();

Обратите внимание, что это означает, что этот поток будет ждать до тех пор, пока t1 и t2 также не будут завершены. Если это не достаточно хорошо для вас, есть различные варианты, но в основном вы хотите, чтобы что-то еще асинхронно ожидало завершения t1 и t2. Например, вы могли бы связать дополнительную нить, чтобы сделать это:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4));
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9));
t1.Start();
t2.Start();
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4));
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9));
Thread t5 = new Thread(() =>
{
    t1.Join();
    t2.Join();
    t3.Start();
    t4.Start();
});
t5.Start();

Немного странно, но это должно сработать.

Вы можете использовать .NET 4.0? Если это так, инфраструктура Parallel Extensions значительно облегчает эту задачу.