Démarrer un thread avec / sans délégué ()

Quelle est la différence entre:

new Thread(new ThreadStart(SomeFunc))

et:

new Thread( delegate() { SomeFunc();} )

Ce code donne étrange sorties sur mon ordinateur:

public class A
{
    int Num;

    public A(int num)
    {
        Num = num;
    }

    public void DoObj(object obj)
    {
        Console.Write(Num);
    }

    public void Do()
    {
        Console.Write(Num);
    }
}

///////in void main()

for (int i = 0; i < 10; i++)
{
    (new Thread(new ThreadStart((new A(i)).Do))).Start(); //Line 1
    (new Thread(new ThreadStart(delegate() { (new A(i)).Do(); }))).Start(); //Line 2
    (new Thread(delegate() { (new A(i)).Do(); })).Start(); //Line 3
}

Si seule la Ligne 1 est exécutée la sortie est quelque chose comme:

0 2 3 1 5 6 4 7 8 9

qui est ok, mais si la Ligne 2 ou 3 est exécutée, la sortie est de:

3 3 3 5 5 7 7 9 9 10

Il y a quelques plusieurs numéros et un 10 qui est assez étrange que la boucle n'est jamais exécuté avec le numéro 10. Quel est le truc derrière ces?

Grâce.

source d'informationauteur ali_bahoo | 2010-11-09

  1. 15

    Avec le délégué, vous capturez i.

    La différence est que, avec new ThreadStart((new A(i)).Do))vous créez une nouvelle instance de A dans le for boucle avec i en tant que paramètre. Cela signifie qu'à ce stade, la valeur de i est pris et l'envoyer au constructeur. Le délégué que vous envoyez est donc pas de la création de Amais vous êtes en fait en envoyant le délégué de la Do méthode de l'instance de A du constructeur.

    Cependant, avec delegate() { (new A(i)).Do(); }) (les deux), vous envoyez une référence de i le fil.

    Le thread prend un peu de temps à démarrer et pendant ce temps, le for boucle continue. Par les temps i est utilisé dans la délégué (c'est à dire que le thread a commencé), la for boucle s'est déplacé sur 3 et c'est ce que vous voyez. Il en va de même pour la deuxième et la troisième fil. Les trois fils sont commencé, mais d'attendre le départ de thread pour la réalisation de certains travaux. Puis les threads créés coup de pied dans (sujet 1, 2 et 3) et qu'ils font leur travail. Le Windows remonte le fil avec la for boucle et va lancer le thread 4 et 5.

    Certains matériels de lecture:

  2. 4

    Pour répondre à votre premier point, delegate() { SomeFunc();} crée une fonction qui s'appelle SomeFunc()alors que n'utilisant pas delegate() utilise simplement le SomeFunc directement à la fonction que le ThreadStart méthode.

    Dans votre deuxième question, vous êtes en cours d'exécution dans les détails de mise en œuvre de C# les fonctions anonymes. Tous les trois références à i reportez-vous à la même iqui est incrémenté à trois reprises. Vous avez une condition de concurrence entre les trois fonctions qui signifie i peut être incrémenté à plusieurs reprises avant que les threads sont exécutés.

  3. 1

    "Quand est le constructeur de l'objet que l'on appelle le?' permet de répondre à la question.

    new ThreadStart((new A(i)).Do))

    Lorsque cette ligne de code est exécuté - le constructeur est appelé, et une référence à la .Do la fonction de l'objet nouvellement créé Un est conservé par le délégué ThreadStart.

    Dans la Ligne 2 et 3, vous êtes à l'aide d'un délégué anonyme (introduit en C# 2.0). 

    delegate() { (new A(i)).Do(); })

    Le contenu du délégué anonyme n'est pas exécutée jusqu'à ce que le délégué est appelé; dans ce cas, par le fil quand il est affecté à une tranche de temps pour le faire.

    La variable i est déclaré seulement une fois au début de la boucle for, et le délégué des contenus a un référence (délégués) - lorsque le code est exécuté, il doit saisir la valeur de i au moment de l'exécution.

    Ce qui explique la valeur 10. je possède une valeur de 10 lorsque la boucle a fini de s'exécuter. Si l'un des threads s'exécute après la boucle est terminée, il sera de sortie 10.

    Pour éviter les multiples numéros de problème, vous pouvez créer une copie locale de la variable de boucle. Le délégué de conserver une référence à sa propre version de icopy;

    for (int i = 0; i < 10; i++)
{
     int icopy = i;
     (new Thread(new ThreadStart(delegate() { (new A(icopy)).Do(); }))).Start();
}