Create class instance in threads

Question

Imagine I have a class:

Class Animal
{
    //Propriedades
}

Now creating multiple instances of the class I do as follows:

Animal[] animais = new Animal[10];
for(int i = 0; i < 10; i++)
{
    animais[i] = new Animal();
}

So far so good, in theory at the end of the execution of the method for I’ll have a array with my 10 instances of the class Animal.

Now I have the following problem:

Each Animal shall be one Thread.

1 - How can I implement this? so that each instance of my class is a Thread?

What I did, and I’m not sure it’s right...

public void ThreadAnimal()
{
    Thread th;
    Animal[] animais = new Animal[10];

    for (int i = 0; i < 10; i++)
    {
        animais[i] = new Animal();
        th = new Thread(new ParameterizedThreadStart(CriarAnimal));
        th.SetApartmentState(ApartmentState.STA);
        th.IsBackground = true;
        th.Start(animais[i]);
    }
}

public void CriarAnimal(object obj)
{
    Dispatcher.Invoke(() =>
    {
        var animal = obj as Animal;
        var img = new Image()
        {
            Source = animal.Img,
            Tag = animal,
            Width = 32,
            Height = 32,
        };

        double posX = _canvas.ActualWidth - img.Width;
        double posY = _canvas.ActualHeight - img.Height;

        Canvas.SetLeft(img, rnd.NextDouble() * posX);
        Canvas.SetTop(img, rnd.NextDouble() * posY);

        _canvas.Children.Add(img);
    });
}

Each Thread created will be an instance? or each Thread is just loading a reference from an instance?

2 - Let’s imagine that the class Animal has a property vida, and when the vida come to 0 the Animal ceases to exist or is my instance/thread are finalized/destroyed, how to implement this?

Answer 1

1. Object instance is object instance. Thread is thread. Except for the fact that a thread is a specific object, one thing has nothing to do with the other.

2. Threads are finished when no longer being used (usually). Object instances are destroyed when they are no longer useful and C# automatically manages this.

   Note that this is a bit more complicated. The object containing the thread can be collected soon after giving the Start(). He is no longer needed after the thread runs. It runs independently.

   To thread as long as what is contained within it (CriarAnimal) is running. Note that it can run even with the "official" closure of the application, since it put on background.

At the end the displayed code will create a array with 10 animals where each one will go through some process of creation. This process is presumed to be long and the 10 may occur in parallel and concurrently, if you have time :).

And it’s important to understand that threads can slow code down and not bring gains, on the contrary. has great chance of the cost of creating a thread be greater than the cost of creating a Animal.

Understand that it is a technique considered almost obsolete. The use of tasks can help a little minimize the waste of creating thread.

See more or less how it would be a for parallel.

See also: What is the difference between async, multithereading, parallelism and competition?.

According to the comments below, the question has been modified, and indicates that this solution seems less suitable yet.

Answer 2

What you did was very confusing, but what you want is impossible.

The Thread class is marked with Sealed, meaning it cannot be inherited, so it is not possible to make an Animal Thread (A bizarre creature), and multiple inheritance in c is impossible#.

But you can always make an Animal that has a Thread (an aggregation), so it can have a dynamic behavior (I think that’s what you really want).

This involves having a loop in Thread execution.

Cada Thread criada será uma instancia? ou cada Thread apenas está carregando uma referência de uma instancia?

Thread itself is an object instance of the Thread type, like any other. When you broadcast Start, it starts executing the delegated function you designated and when you finish it closes. This execution does not block your execution flow (usually the Thread of the interaction, but the interface runs on a Thread as well), as you may already know, the Thread is staggered and executed in "parallel" (or time-division, or actually parallel if you have multiple processor cores).

2 - Imaginemos que a classe Animal tem uma propriedade vida, e quando a vida chegar a 0 o Animal deixa de existir ou seja minha instancia/thread são finalizadas/destruídas, como implementar isso?

The delegated function should be something like:

private void LoopAnimal()
{
  while(estaVivo)
  {
    //Executar ações do Animal, detectar colisões, implementar comportamentos etc..
    ExecutarComportamentoDoAnimal();
    if(Vida == 0)
      estaVivo = false;
    //Para você não consumir todo o processador deve esperar algum tempo entre cada iteração, o sistema operacional agenda o retorno a essa tarefa, isso não tem muito boa precisão, se você precisa de alta precisão no tempo pesquise por Multimedia Timer, evite bloquear a Thread pois seu processador vai a 100%
    Thread.Sleep(100);
  }
  //Aqui você pode emitir um evento sinalizando que a Thread terminou, isso é necessário pois a Thread não tem um evento que sinaliza o fim (algo do tipo Thread.Exited)
  AnimalMorreu();
}

You can also use Task, the concept is +/- the same, but internally it has a Thread (which is the lowest level element of parallelism).