Každý programátor vie načo slúži paralelné programovanie. Princípy sú rovnaké u všetkých programovacích jazykov, avšak deklarácia je rôzna.
Navrhol som knižnicu pre paralelné programovanie vo vláknach pre konzolové a DLL aplikácie.
 

Určite sa väčšina niekedy stretla s problémom, ktorý potrebovala v konzolovej aplikácii vyriešiť prostredníctvom paralelného programovania.
Nakoľko je však deklarácia vlákien v konzolovej aplikácii oproti Windows Form úplne rôzna a v konzolovej aplikácii omnoho zložitejšia, určite každý z vás ocení modul, ktorý som sám navrhol pre uľahčenie paraleného programovania.

Modul obsahuje štruktúru tried, ktoré sa starajú o spustenie danej funkcie a jej časovania. Je možné nastaviť každému vláknu dva časovače metódou:

   void SetTimer(Call behindcall, Call aftercall) 

Parameter "behindcall" udáva čas, za aký sa má funkcia spustiť, teda čas ktorý definuje, ako dlho má byť vlákno pozastavené pred tým, než sa funkcia vykoná.

Parameter "aftercall" udáva čas ktorý definuje ako dlho má byť vlákno pozastavené po vykonaní funkcie.

Názov funkcie, ktorá má byť vo vlákne časovaná sa vkladá do metódy:

   bool StartTimer(bool (*function)()) 

Funkcia, ktorej názov sa vkladá do metódy StartTimer, musí byť statická! Nesmie to byť funkcia volaná z inštancie triedy!

Samotné vlákno v Console application, v ktorom sa spúšťajú predchadzajúce metódy, je nutné deklarovať makrom:

   unsigned int __stdcall

Samotné vlákno v DLL application, v ktorom sa spúšťajú predchadzajúce metódy, je nutné deklarovať makrom:

   void _cdecl 

alebo

   void 

Príklad použitia Console Application:

   #include "thread.h"


   bool Foo1(void)
   {
       ::std::cout << "Hello Word" << endl;
       return 0;
   }

   bool Foo2(void)
   {
       ::std::cout << (1+5)-3 << endl;

       if((1+5)-3 == 3)
       {
           return true;
       } else return false;
   }

   unsigned int __stdcall _Thread1(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(0,2000);
       return threadtimer->StartTimer(Foo1);
   }

   unsigned int __stdcall _Thread2(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(1000,5000);
       return threadtimer->StartTimer(Foo2);
   }

   int main(void)
   {
       // Deklaracia ID vlakien //
       ::Threading::ThreadID thread1 = 0;
       ::Threading::ThreadID thread2 = 1;

       // Inicializacia a spustenie vlakien //
       ::Threading::ThreadHandle tHandle1 = ::Threading::MultyThreads->ThreadStart(_Thread1, NULL, &thread1);
       ::Threading::ThreadHandle tHandle2 = ::Threading::MultyThreads->ThreadStart(_Thread2, NULL, &thread2);

       // Cakanie na dokoncenie vlakien //
       ::Threading::MultyThreads->WaitingForThread(tHandle1);
       ::Threading::MultyThreads->WaitingForThread(tHandle2);

       // Ukoncenie vlakien //
       ::Threading::MultyThreads->CloseThread(tHandle1);
       ::Threading::MultyThreads->CloseThread(tHandle2); 

       return 0;
   }

Príklad použitia volaní funkcií z inštancií triedy::

   #include "thread.h"

   class Foo
   {

   private:

       int a;
       int b;
       int c;

   public:
       Foo(void)
       {
           this->a = 1;
           this->b = 5;
           this->c = 3;
       }

       bool Foo1(void)
       {
           ::std::cout << "Hello World" << endl;
   
           return 0;
       }
 
       bool Foo2(void)
       {
           ::std::cout << (a+b)-c << endl;

           if((a+b)-c == 3)
           {
               return true;
           } else return false;
       }
   }
    Foo * foo = new Foo();



   bool A(void)
   {
       return foo->Foo1();
   }

   bool B(void)
   {
       return foo->Foo2();
   }

   unsigned int __stdcall _Thread1(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(0,2000);
       return threadtimer->StartTimer(A);
   }

   unsigned int __stdcall _Thread2(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(1000,5000);
       return threadtimer->StartTimer(B);
   }

   int main(void)
   {
       .
       .
       .
   }

Príklad použitia DLL Application:

   #include "thread.h"


   bool Foo1(void)
   {
       ::std::cout << "Hello Word" << endl;
       return 0;
   }

   bool Foo2(void)
   {
       ::std::cout << (1+5)-3 << endl;

       if((1+5)-3 == 3)
       {
           return true;
       } else return false;
   }

   void _Thread1(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(0,2000);
       return threadtimer->StartTimer(Foo1);
   }

   void _cdecl _Thread2(void * input)
   {
       ::Threading::MultyThreadsW::Timer * threadtimer = new ::Threading::MultyThreadsW::Timer();
       threadtimer->SetThreadTimer(1000,5000);
       return threadtimer->StartTimer(Foo2);
   }

   void OnRunProcess(void)
   {
       // Deklaracia ID vlakien //
       ::Threading::threadId thread1 = 1;
       ::Threading::threadId thread2 = 2;

       // Inicializacia a spustenie vlakien //
       ::Threading::ThreadHandle tHandle1 = ::Threading::MultyThreads->ThreadStartDLL(_Thread1, 0, &thread1);
       ::Threading::ThreadHandle tHandle2 = ::Threading::MultyThreads->ThreadStartDLL(_Thread2, 0, &thread2);

     //alebo

       // Inicializacia a spustenie vlakien //
       ::Threading::ThreadHandle tHandle1 = (HANDLE) _beginthread(_Thread1, 0,&thread1);
       ::Threading::ThreadHandle tHandle2 = (HANDLE) _beginthread(_Thread2, 0,&thread2);

       // Ukoncenie vlakien //
       ::Threading::MultyThreads->CloseThread(tHandle1);
       ::Threading::MultyThreads->CloseThread(tHandle2); 
   }


   BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
   {
       switch (reason)
       {
          case DLL_PROCESS_ATTACH:
            //MessageBoxA(0, "Process is Attach", "Attach", MB_OK);
            OnRunProcess();
          break;

          case DLL_PROCESS_DETACH:
            //MessageBoxA(0, "Process is Detach", "Detach", MB_OK);
            //OnDeatachProcess();
          break;

          case DLL_THREAD_ATTACH:
            //MessageBoxA(0, "Thread is Attach", "Detach", MB_OK);
            //OnRunThread();
          break;

         case DLL_THREAD_DETACH:
           //MessageBoxA(0, "Thread is Detach", "Detach", MB_OK);
           //OnDeatachThread();
         break;

         default :
           //Others();
    };
    return TRUE;
}

thread.h
---------------------------------------------------------------------
Vývojový jazyk: C++
Typ vývojového prostredia: Visual Studio IDE
Posledná revízia: 11.11 2018
Autor: Diallix

Download Header: Download

---------------------------------------------------------------------

​