Multithread


Thread

When a program runs, it typically has one thread (called the main thread). On a Windows Application, this thread is used for the Graphic User Interface and the program computation (in this case it is called the GUI thread). For instance, when the user clicks a button to execute a function of the program, this may take little or long time to execute depending on the complexity of the function. If the function takes long to execute, the program GUI will be frozen while the function executes. The rule is that if a function takes more than 0.5 seconds to execute, the programmer must create another thread to execute the function. In the figure below the main thread is displayed in green.
Cuando un programa se ejecuta, éste típicamente tiene una thread (llamada al thread principal). En una aplicación de Ventana, esta thread es usada para Ia Interface Gráfica del Usuario y los cálculos del programa (en este caso, esta es llamada la thread para la GUI). Por ejemplo, cuando el usuario hace clic en un botón para ejecutar una función del programa, esta puede tomar poco o mucho tiempo para ejecutarse dependiendo de la complejidad de la función. Si la función toma mucho en ejecutarse, la GUI del programa se congelará mientras que la función se ejecuta. La regla dice que si una función toma más de 0.5 segundos para ejecutarse, el programador debe crear otra thread para ejecutar la función. En la figura de abajo la thread principal es mostrada en verde.

MainThread

Worker Thread

The main thread is typically used for the GUI. In heavy computation programs, there is an additional thread called the Worker Thread that performs most background computations as shown in the figure below. To begin a new thread you must call the _beginthreadex API.
La thread principal es típicamente usada por la GUI. En programas de cálculos pesados, hay una thread adicional llamada la Worker Thread que realiza la mayoría de los cálculos en segundo plano como se muestra en la figura siguiente. Para comenzar una nueva thread usted debe llamar the _beginthreadex API.

WorkerThread

_beginthreadex

The _beginthreadex API returns a handle to the new thread. This handle must be stored (in a variable of the type HANDLE) so that we can manipulate the thread. Typically, you should wait for the thread to complete using the WaitForSingleObject API. When the thread has completed, you must call the CloseHandle API to close the thread.
La API _beginthreadex regresa un handle a la nueva thread. Este handle debe ser guardado (en una variable del tipo HANDLE) para poder manipular la thread. Típicamente, usted debe esperar a que la thread complete usando la API WaitForSingleObject. Cuando la thread ha terminado, usted debe llamar la API CloseHandle para cerrar la thread.

Tip
Wintempla provides a set of classes in the Mt namespace, you can use these classes or you can create your own clases. Any program that wants to start a new thread must implement the Mt::IThread interface. Any object that implements this interface can be passed to a Mt::ThreadObject object for execution. The Mt::ThreadObject class is very simple; if you do not want to use it, you may use instead the _beginthreadex API.The figure below shows how to use Wintempla to create a new thread using the Mt::ThreadObject class. First, your program must implement the Mt::IThread interface. Second, you have a member variable of the type Mt::ThreadObject. Third, you must call the ThreadObject::StartThread function passing the object that implement the Mt::IThread interface.
Wintempla proporciona un conjunto de clases en el namespace Mt, usted puede usar estas clases o usted puede crear sus propias clases. Cualquier programa que quiere comenzar una nueva thread debe implementar la interface Mt::IThread. Cualquier objeto que implementa esa interface puede ser pasado a un objeto del tipo Mt::ThreadObject para ser ejecutado. La clase Mt::ThreadObject es muy simple; si usted no quiere usarla, usted puede en su lugar usar la API _beginthreadex.La figura de abajo muestra cómo usar Wintempla para crear una nueva thread usando la clase Mt::ThreadObject. Primero, su programa debe implementar la interface Mt::IThread. Segundo, usted debe tener una variable miembro del tipo Mt::ThreadObject. Tercero, usted debe llamar la función ThreadObject::StartThread pasando un objeto que implementa la interface Mt::IThread.

ThreadObject

Tip
As a computer has a limited number of resources, you must try to avoid creating too many threads. The number of threads is basically limited by the number of processors (and cores) in the computer. If a program has too many threads, each core will perform a little work in each thread at a time. As switching among thread is an expensive operation, a lot of precious CPU time will be wasted. In Server applications, you must try to save CPU time.
Como una computadora tiene un número limitado de recursos, usted debe tratar de evitar de crear demasiadas threads. El número de threads está limitado en su forma básica por el número de procesadores (y de núcleos) en la computadora. Si un programa tiene muchas threads, cada núcleo realizará un poco de trabajo en cada thread a la vez. Como cambiarse entre threads es una operación costosa, mucho tiempo valioso de CPU será consumido. En aplicaciones para Servidor, usted debe tratar de ahorrar tiempo de CPU.

C++ 11 threads

Starting in version 11, the language C++ supports threads by including the <thread> header file. To begin a thread, you will need to pass a global function or static member function of a class to the thread as shown in the following example.
A partir de la versión 11, el lenguaje C++ suporta las threads incluyendo el archivo de encabezado <thread>. Para iniciar una thread, usted necesitará pasar una función global o una función estática miembro de una clase a la thread como se muestra en el siguiente ejemplo.

Program.h
#pragma once //______________________________________ Program.h
#include "resource.h"
#include <thread>

class Program: public Win::Dialog
{
public:
     Program()
     {
     }
     ~Program()
     {
     }
     std::vector<std::thread> threadPool;
     static void SomeFunc(int a, double b);
     ...
};


Program.cpp
void Program::Window_Open(Win::Event& e)
{
     //______________________________________________ 1. Creates a dynamic array of threads
     size_t i;
     const size_t numThreads = std::thread::hardware_concurrency();
     threadPool.resize(numThreads);
     //______________________________________________ 2. Start each thread
     for ( i = 0; i < numThreads; i++)
     {
          threadPool[i] = std::thread(SomeFunc, 10, 4.5); //Executes SomeFunc(10, 4.5);
     }
     //______________________________________________ 3. Wait for each thread to complete
     for ( i = 0; i < numThreads; i++)
     {
          threadPool[i].join();
     }
}

void Program::SomeFunc(int a, double b)
{
     // Do some heavy work
}

© Copyright 2000-2019 Wintempla selo. All Rights Reserved. Sep 05 2019. Home