Comment mettez-vous un objet dans un autre thread?

est-il possible en c# pour mettre les objets dans un autre thread? Tout ce que je trouve est comment exécuter certaines méthodes dans un autre thread. Ce que je veux faire, c'est d'instancier un objet dans un nouveau thread pour l'utilisation ultérieure des méthodes qu'il fournit.

Espère que vous pourrez m'aider,
Russo

source d'informationauteur Russo

c#multithreading

25

Objets n'appartiennent pas vraiment à un fil. Si vous avez une référence à un objet, vous pouvez y accéder à partir de plusieurs threads.

Cela peut donner des problèmes avec des objets qui ne sont pas conçus pour être accessibles à partir de plusieurs threads, comme (presque tous).De Windows.Les formes des classes, et l'accès à des objets COM.

Si vous ne souhaitez accéder à un objet de la même thread, stocker une référence à un fil en objet (ou un habillage de l'objet), et d'exécuter les méthodes via ce thread.
14

Il semble y avoir une certaine confusion à propos de la façon dont les threads de travail ici, c'est donc un apprêt (très court, trop, de sorte que vous devriez trouver plus de matériel avant de s'aventurer plus loin dans le multi-thread de programmation.)

Des objets et de la mémoire sont intrinsèquement multi-thread dans le sens que tous les threads d'un processus peut accéder comme ils le souhaitent.

Si les objets n'ont rien à voir avec les threads.

Cependant, le code s'exécute dans un thread, et c'est le fil le code s'exécute dans laquelle vous êtes probablement après.

Malheureusement, il n'existe aucun moyen de "mettre un objet dans un autre thread" comme vous l'avez dit, vous avez besoin spécifiquement pour démarrer un thread et indiquez le code à exécuter dans le thread. Objets utilisés par ce code peut donc être "dit" d'appartenir à ce thread, mais c'est une limite artificielle vous imposer à vous-même.

Il n'existe aucun moyen pour ce faire:
```
SomeObject obj = new SomeObject();
obj.PutInThread(thatOtherThread);
obj.Method(); //this now executes in that other thread
```
En fait, un piège commun de nombreux nouveaux multi-thread programmeurs tomber dans, c'est que si ils créer un objet dans un thread, et appeler des méthodes sur un autre thread, toutes ces méthodes s'exécuter dans le thread qui a créé l'objet. Ceci est incorrect, les méthodes de toujours s'exécute dans le thread qui a appelé.

Donc la suite est également incorrect:
```
Thread 1:
    SomeObject obj = new SomeObject();

Thread 2:
    obj.Method(); //executes in Thread 1
```
La méthode s'exécute dans le Thread 2. La seule façon d'obtenir la méthode à exécuter dans le thread d'origine est de coopérer avec le fil d'origine et de "poser" pour l'exécution de cette méthode. La façon de le faire dépend de la situation et il y a beaucoup, beaucoup de manières de le faire.

Donc, pour résumer ce que vous voulez: si Vous souhaitez créer un nouveau fil de discussion, et d'exécuter du code dans ce thread.

Pour ce faire, regardez le Fil classe de .NET.

Mais attention: applications Multi-thread sont extrêmement difficiles à obtenir correct, je ne voudrais pas ajouter multi-thread des capacités à un programme, à moins:
1. C'est la seule façon d'obtenir plus de performance et de
2. Et, vous savez ce que vous faites

Tous les threads d'un processus partagent les mêmes données (en ignorant thread local storage) donc il n'est pas nécessaire explicitement migrer les objets entre les threads.

internal sealed class Foo
{
    private Object bar = null;

    private void CreateBarOnNewThread()
    {
        var thread = new Thread(this.CreateBar);

        thread.Start();

        //Do other stuff while the new thread
        //creates our bar.
        Console.WriteLine("Doing crazy stuff.");

        //Wait for the other thread to finish.
        thread.Join();

        //Use this.bar here...
    }

    private void CreateBar()
    {
        //Creating a bar takes a long time.
        Thread.Sleep(1000);            

        this.bar = new Object();
    }
}

2

Tous les threads peuvent voir les ~~pile~~ tasde sorte que si le thread a une référence pour les objets dont vous avez besoin (transmis par le biais d'une méthode, par exemple), alors le fil de l'utilisation de ces objets. C'est pourquoi vous devez être très prudent à l'accès à des objets lorsque le multi-threading, que deux threads peuvent essayer et de modifier l'objet en même temps.

Il y a un ThreadLocal<T> classe .NET que vous pouvez utiliser pour limiter les variables à un thread spécifique: voir http://msdn.microsoft.com/en-us/library/dd642243.aspx et http://www.c-sharpcorner.com/UploadFile/ddoedens/UseThreadLocals11212005053901AM/UseThreadLocals.aspx
1

Utilisation ParameterizedThreadStart à passer un objet à votre fil.
0

"pour l'utilisation ultérieure des méthodes qu'il fournit."

À l'aide d'une classe qui contient la méthode à exécuter sur nouveau fil de discussion et d'autres données et méthodes, vous pouvez accéder à partir de votre fil de Données et les méthodes de la nouvelle thread.

Mais ... si votre exécuter une méthode de la classe, vous sont en cours d'exécution sur le thread courant.

Pour exécuter la méthode sur le nouveau thread besoins du Fil de synchronisation.

Système.De Windows.Les formulaires.De contrôle.BeginInvoke le faire, le Contrôle de la thread est en attente jusqu'à l'arrivée des demandes.

WaitHandle classe peut vous aider.

Désolé pour dupliquer quelques travaux antérieurs, mais l'OP dit

Ce que je veux faire, c'est d'instancier un objet dans un nouveau thread pour l'utilisation ultérieure des méthodes qu'il fournit.

Permettez-moi de l'interpréter comme:

Ce que je veux faire est d'avoir un nouveau thread instancier un objet de sorte que plus tard que je peux utiliser de l'objet de méthodes.

Prier corrigez-moi si j'ai oublié la marque. Voici l'exemple:

namespace  silly
{
public static class Program
{
//declared volatile to make sure the object is in a consistent state
//between thread usages -- For thread safety.
public static volatile Object_w_Methods _method_provider = null;
static void Main(string[] args)
{
//right now, _method_provider is null.
System.Threading.Thread _creator_thread = new System.Threading.Thread(
new System.Threading.ThreadStart(Create_Object));
_creator_thread.Name = "Thread for creation of object";
_creator_thread.Start();
//here I can do other work while _method_provider is created.
System.Threading.Thread.Sleep(256);
_creator_thread.Join();
//by now, the other thread has created the _method_provider
//so we can use his methods in this thread, and any other thread!
System.Console.WriteLine("I got the name!!  It is: `" + 
_method_provider.Get_Name(1) + "'");
System.Console.WriteLine("Press any key to exit...");
System.Console.ReadKey(true);
}
static void Create_Object()
{
System.Threading.Thread.Sleep(512);
_method_provider = new Object_w_Methods();
}
}
public class Object_w_Methods
{
//Synchronize because it will probably be used by multiple threads,
//even though the current implementation is thread safe.
[System.Runtime.CompilerServices.MethodImpl( 
System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]
public string Get_Name(int id)
{
switch (id)
{
case 1:
return "one is the name";
case 2:
return "two is the one you want";
default:
return "supply the correct ID.";
}}}}

0

Tout comme pour élaborer une réponse précédente. Pour en revenir au problème, les objets et l'espace de mémoire sont partagées par tous les threads. Donc, ils sont toujours partagés, mais je suis en supposant que vous voulez le faire en toute sécurité et de travail avec des résultats créé par un autre thread.

Tout d'abord essayer l'un de confiance C# modèles. Async Modèles
Il y a des modèles avec qui travailler, qui ne transmettent pas de base de messages et de données entre threads.
Habituellement, une menace se termine après il calcule les résultats!

Menace sur la vie: Rien n'est infaillible quand il va asynchrone et de partage des données sur la vie des menaces.
Donc, fondamentalement, de le garder aussi simple que possible si vous avez besoin d'aller dans cette voie et essayer de suivre des schémas connus.

Donc maintenant, j'ai juste un plaisir de vous expliquer pourquoi certains modèles ont une certaine structure:

Eventargs: lorsque vous créez un propriétédeepcopy des objets avant de les transmettre. (Il n'est pas infaillible car certaines références peuvent encore être partagée . )
En passant résultats avec les types de base, comme int flotteurs, etc, ceux-ci peuvent être créés sur un constructeur et un fait immuable.

Atomique mots-clés un de ces types, ou de créer des moniteurs etc.. en tenir à un seul thread lit l'autre écrit.

En supposant que vous avez données complexes-vous travailler avec sur deux threads simultanément un complètement différentes méthodes pour résoudre ce problème , que je n'ai pas encore testé:
Vous pouvez stocker les résultats dans la base de données et de laisser les autres exécutable lire. ( Il y a des verrous se produisent sur une ligne de niveau, mais vous pouvez essayer à nouveau ou de modifier le code SQL et au moins vous aurez signalé les blocages qui peuvent être résolus avec un bon design, pas seulement la pendaison de logiciel!!) Je voudrais faire cela seulement si il fait réellement sens pour stocker les données dans une base de données pour d'autres raisons.

Un autre moyen qui permet de programmer F# . Il y les objets et tous les types sont immuables par défaut/de Sorte que vos objets que vous souhaitez partager doit avoir un constructeur et pas de méthodes de permettre à l'objet de se changer ou de types de base à incrémentée.
Ainsi, vous créez et puis, ils ne changent pas! Ils sont donc non modifiable par la suite.
Système de verrouillage, et travailler avec eux en parallèle de manière beaucoup plus facile. Ne pas devenir fou avec ce dans les classes C#, car d'autres pourraient suivre cette "convention" et la plupart des choses comme les Listes n'étaient tout simplement pas conçu pour être immuable en C# ( readonly n'est pas le même comme immuable, const est mais c'est très limite). Immuable contre readonly
-1

Si la méthode que vous exécutez dans un thread réside dans une classe personnalisée, vous pouvez avoir des membres de cette classe afin de conserver les paramètres.
```
public class Foo
{
object parameter1;
object parameter2;
public void ThreadMethod()
{
...
}
}
```

Vous devez vous connecter pour publier un commentaire.