

  .   .   "OS/2 "                             5


	                 


.  ⠪  ?
.     DosCreateThread()
. 室  
.   ६
. । ࠬ஢  
. ⨭  ࠧ塞 
. ᪨ ᥪ樨  ⠭ ⥩
. ਧ    


      ।饩      ᪠뢠    ⨧
ன.  ⮩       "    ".  ᫨    
믮  ணࠬ ६ -  ᯮ ,  ᫨
   믮   p   㭪樨 -    㦥 ᯮ
.      ਬ   ᯮ    ᮢ. 
᭮ ⨧筮 ᮢ  OS/2   (   쭥襬  
㤥 뢠  ⠪           ).

     稭  ᬮ७  pp ࠡ . ⮬   
            ⠭  㣨       
ᯮ        ६    . ⥬ 
஢ਬ    ࠧ    ᯮ  騩    ।
ࠬ  .   ᫥㥬 ᪨ ᥪ樨,   
   ਮ⠭ 믮  㣨   .  
      믮  ⥩     ६.  ⠪
㢨     ⫮ 믮  㣨 ⥩. 稬  
᪮쪨 ਬࠬ ਬ ⥩.

                            

      ணࠬ    믮  ⢫  믮
᫥⥫쭮  権,  室      設.   
⨢஢  ᫥⥫쭮  믮塞  権 뢠
           믮.         ।     楯窨
(᫥⥫쭮)  ᯮ  㪠⥫,    㪠뢠  
᫥ ,    믮. 筮  㪠⥫
६頥  ᫥⥫쭮     砫   ,  ⬥   
  ᫥⥫쭮,    ய᪠  
⪨   (    믮   横,맮    㭪権       
᫥⥫   p権).         㪠⥫    権
᫥ 믮 । .

      稭 믮 ⢥ .    
 ⮩    ਢ ਬ     ᯮ짮
⢥   .    ,            ஦  
ᯮ짮 API-㭪樨     ⠪     ஦
 .    믮 ६. 祬   㦭?
  ।⠢,           ᢮  ᮡ⢥ 㪠⥫,
뢠騩 ⮯ ⥪饩  樨  .  ஢騪
। ࠧ蠥  㪠⥫  .  १ ६
祭 , ⮬ ᮧ ⫥ ६ 믮.

    ਢ  ⮩ ਬ,   ஬     ஦
.ࢠ  ⮬ 뢮  ࠭  -,⮣    -
 મ.  ਬ  ਢ  ।饩 .   ⮬
ਬ ࠧ  頫 ᨬ  ࠭.   砥,
 ᬮ७ ⥩, ⮡ࠦ ᨬ  ࠭  
⮣  .  ࠡ 宦   ணࠬ  몥  ,
 㭪  main() ।⠢  ᮡ ⠪   䠩,     㣨
뢠 짮⥫᪨ 㭪樨.

/* simpleth.c */
/* ஦   㣮 */

#define INCL_DOS
#define <os2.b>
#define <malloc.h>
#define STACK_SIZE 1024    /* pp ⥪   */

main()
{
 char far *stkptr;         /* 㪠⥫ ⥪     */
 void far NewTread();      /* ⨯            */
 unsigned threadID;        /* ID -                */
 unsigned rc;              /*                   */

                           /* 뤥 ⥪    */
 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

                           /*                */
 if ( rc = DosCreateThread(NewThread, &threadID, stkptr) )
    { printf("DosCreateThread error=%u/n",rc); exit(1); }

 while( !kbhit() )         /* 室        */
    printf("X");
 exit(0);                  /* 뢠  ⥩        */

}
/* NewThread()  */
/*    ⮬    */

void far NewThread()
{
  while(TRUE)
      printf("-");
}
    ,  뢠  NewThread()   祭    㭪.   
 ࠧ  main()  뢠  㭪   ᯮ짮
᪮.

   筮 ࠢ  ।  (  砥 -  㭪)
  ⨢   㭪樨 main().

    ᪠   API - 㭪樨 DosCreateThread().  
ணࠬ  뢠  㭪,  ࠢ  ।     뢠饩
ணணࠬ ⮩  㭪樨;   ⮬ 뢠  ணࠬ ४頥
믮   ,  㭪  ୥  ࠢ.   ,
⮢,    ᮧ  㣨  ,  祬    ᮧ,   
ᮧ   믮 ६.

      ⮬ 㡥, ஢ਢ १ ணࠬ simpleth.c .

ͻ
 --------------------------------------------------------------- 
 ----------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX------------------------------ 
 -------------------------------------------------XXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XX------------------------------------------------------------- 
 ---------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXX-------------------------------------------------------- 
 -----------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX--------------------- 
 -------------------------                                       
ͼ

     ""    "-"  ।    뫠 ᮮ騥
ᨬ  ࠭.  ,   믮 ६.


㭪 DosCreateThread()

   㭪      ࠬ  :    室      室.
ணࠬ    ।    ⪠ ,  稭
.            ᠭ      㭪樨,  
ᯮ짮 ᮣ襭 몠   ।⠢-     
.  襬 ਬ  㤥 ६ NewThread().

    DosCreateThread       -   㭪 ᮧ  
Ŀ
   DosCreateThread(Address,AThread ID,StackPtr);                
   void (far *)(void) Address;         /*            */
   void far *AThreadID;       /*  䨪     */
   void char far *StackPtr ;       /*   ⥪     */

          ,         ᮧ  砥  㭨,
騩    .   㭪  DosCreateThread()   頥
䨪        ६,   ன ᮤন 
஬  ࠬ  㭪樨.     쭥襬    室   
䨪  ᯮ짮  ணࠬ  饭  . 
    (     ᬮ  ᪮  㡥)    
室  ⭮ 樨 -  ⠭     
ਮ.


                              

    ⨩  ࠬ  DosCreateThread()  -      ,
१ࢨ஢  ⥪   .  筮 㭪樨  몠
,   ᯮ ᢮ ᮡ⢥  ⥪, ⫨ 
   뢠饩   ணࠬ.    ⥪     ⮬᪨
१ࢨ automatic ६:   ६   ᮧ   
 ᮧ 㭪樨    㤠    砭.

     ,   ६  ⥪   㭪権 몠 
ᮧ  ⮬᪨,  ⥪      ⥩    
। ணࠬ⮬   .       祭
㤮 짮⥫,  ,   㣮 ஭,      
஫஢ ࠧ ⥪.      ⥪  ।  
ᯮ짮뭨 㭪樨 ⥪  malloc().
    ப  뤥 ⥪  :

       stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

   㭪 malloc()  頥 㪠⥫       뤥
   .       DosCreateThread()   室  ।
砫    ⥪.    ⮣    㪠⥫   ࠧ
뤥 ,     5-1.

   ᪨,      㭪, 室  㪠⥫ 㪠뢠 
᫮ , ।饥 ⥪.  ᫥饬 ࠧ  㢨, 
 ᯮ  । ࠬ஢ .

    ⪮  ᪠  ਬ ஢  㫥 
襭 㭪樨  malloc().   襭    ⢨
ॡ㥬    ,    ⮬,    㦥 .
  쥧 ணࠬ ⠪ 砩   ।ᬮ७.

ͻ
                                                    
                                                            
                             㪠⥫,                         
                             ।  DosCreateThread()   
                            <                          
            /͵ 設 ⥪                      
          /                 <                          
        /    Ĵ                                    
                                                               
             .              .   Ŀ             
              .              .   !⥪  !             
              .              .                
                                                               
                                                               
       \     Ĵ 㪠⥫ ᫥ 뤥          
         \                  ⥪   . malloc()   
           \                <                          
              ͵                                    
                                                                
                                                                  
                                                     
                                                            
ͼ

  . 5-1. ⥫ ⥪ .


                          

     묨  ⮢.   砥, 
஢騪  ।  ६  業ࠫ쭮   ()  
ﬨ,   ᠬ.   ᯮ  ᢮ १  ६
 ⥬ । ࠢ ᫥饩  .    ࠧ, ,
騩   ,  ᪮쪮  ६ , 
  .5-2.

     ⠪   ᪠,   ᠬ     㭪樮  -
㭪樮   ᮢ.  뫮  祭    ।饩
,   ᮡ⢥묨 ᠬ.      
 ,    ࠡ.

Ŀ
                           ﬨ                               
        <<Ŀ        
                                                                        
                                                                        
 ͻ    ͻ
       >   >    >   >        
   Ŀ  Ŀ  Ŀ       Ŀ   Ŀ   
     1     1     1          1      1    
                    
 ͼ    ͼ
                                                                          
               1                                2           

   . 5-2.  ᯥਧ樨.


                          

    ।饩   ,  ᮧ    ॡ
筮 讣 ६, ⠪  䠩   ⠭  ᪠ 
ࠧ饭  .      ந室  ⥫쭮 ॥.
६ ᮧ  ࠢ   맮 㭪樨   몥     ⮬, 
뢠 㭪  室   ⮬   䠩, 㤠   맮.
,      㭪,  㦠          뢠饩
ணࠬ, ⠪ ࠧ  室  饭     
  ᯮ짮  ⨢樨 㣨 ⥩.

       ᪮  㢨, ࠧ   ﬨ ⠪ ,
祬  ᠬ.

           

     㭪樨  ,  ᫥  뢠  ⥩. ᫨
뢠  (த⥫᪠)    뢠  䠩,    ਬ,   
㯥  ୨ .  ᫨ ୨  뢠 䠩,  
㯭  த⥫᪨      ᮧ .    
 ᪠   ᯮ ᢮ .   
    騬 ᠬ, ᨬ  ⮣   
뫠  ᮧ .

    쪮  ਧ (஬  䨪) ⫨    
㣮.      ᢮ ᮡ⢥ ⥪   
    ᮡ⢥  㠫  ॣ  , 騩 稪
 ( 㪠뢠  ⥪饩 ᯮ塞 樨). 
  믮,  ᮤন    㠫쭮 ॣ 頥 
ॠ ॣ  .      믮, ᮤন ॣ
࠭   쭥襬 ⠭  믮 ⮩ .


                       

 ⮦ ࠧ稥  ﬨ  ᠬ.

                                          

ணࠬ-।塞               㭪樮쭮-।塞
(। ணࠬ)             (। 㭪樥)
                                 
⥫쭮 ᮧ                   ஥ ᮧ
                                 
                     ⮥  ஥ ࠧ 
ࠧ                 
                                 
⢥                    ⢥ ⥪  
(䠩,)                        ॣ
                                 
                                        ᯥਧ樨

                                    CHAPTER 5

     筠  㭪      믮,       
ࠢ ணࠬ     ਩   襭,  ᫥
믮 । RETURN.     ᯮ짮   ਥ
( ⪠  ਬ  ਢ  ண㥬 室).  
  稢  믮,     । ࠢ 뢠饩
.   ४頥 믮.  ந  
API-㭪樨 DosExit().

          DosExit()    -     室    
Ŀ
DosExit(Action,Rezult);                                       
unsigned Action;            /* 0 - ⥪. ; 1 -   */ 
unsigned Rezult;            /*                  */ 

       㭪       ࠬ.    -     樨,
㪠뢠騩 襭  (Action = 0)   (Action = 1) ⥩
,        襭  ᠬ  .  ன 砩
ᬠਢ  㤥, ⠪   襭    
㭪 exit().

    騩      ।⠢   ᮡ   ஥  祭,
뤠  襭 , 筮 exit(). ᫨  
  ୥  ,  १騩        ⠭
த⥫᪨ ᮬ   DosCWait(),  ᠭ   ।饩
. 筮   ଠ쭮  室   뢥襭 ࠢ  . 
襭, ࠢ  1  ࠢ    襭  訡.   
 ७ ணࠬ  㫥 祭  ࠪਧ
⥯ ᭮ 襭.

     ਫ  ⮬,   ਢ  㭨⮦  
㣨    DosKillProcess()    .     ६
⫮ 믮 㣨,   㤠   ணࠬ.

                              CHAPTER 5

    ਢ  ਬ,   ஬    ᯮ DosExit()
 ᢮ ࠧ쭮  襭,    ணࠬ த
믮   ⠭ ஬.   ணࠬ  ⠪ 뢠,
 த⥫᪠  ᮧ  ୨.


/* threxit.c */

/* ਬ  dosexit()         */

#define INCL_DOS
#define <os2.h>
#define <malloc.h>
#define STACK_SIZE 1024    /* pp ⥪   */
#define ACTION 0           /* 0-⥪.  , 1-    */
#define REZULT 0           /* 頥         */

main()
{
 char far *stkptr;         /* 㪠⥫ ⥪     */
 void far thread1();       /* ⨯ ࢮ          */
 void far thread2();       /* ⨯ ன          */
 unsigned thread1ID;       /* ID -  1-          */
 unsigned thread2ID;       /* ID -  2-          */
 unsigned rc;              /*                   */


                           /* 뤥 ⥪    */

 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

                           /*  ࢮ              */

 if ( rc = DosCreateThread(thread1, &thread1ID, stkptr) )
    { printf("DosCreateThread error=%u/n",rc); exit(1); }

                           /* 뤥 ⥪    */

 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

                           /*  ன             */

 if ( rc = DosCreateThread(thread1, &thread2ID, stkptr) )
    { printf("DosCreateThread error=%u/n",rc); exit(1); }

 while( !kbhit() )         /* 室        */
    printf("X");
 exit(0);                  /* 뢠  ⥩        */

}


/* thread1()  */
/*    ⮬    */

void far thread1()
{
 int j;
 for (j=0; j<200; j++)
 printf("-");
 printf("\Thread 1 ending\n");
 DosExit(ACTION,REZULT);
}

/* thread2()  */
/*    ⮬    */

void far thread2()
{
 int j;
 for (j=0; j<300; j++)
 printf("*");
 printf("\Thread 2 ending\n");
 DosExit(ACTION,REZULT);
}

      , 騥 ᮡ⢥  ⥪  ⥩.
 䨪 ⥩  ( ࠢ,   ணࠬ 
 ᯮ).

    ࢠ      ⠥  200 મ  ⠭,
 ⠥ 300 祪.       ࢠ
믮  , 饩 "" - .

ͻ
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX------------------------------- 
 -----------------------------------------------------********** 
 ***********************************************************XXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX---------------------- 
 --------------                                                  
 Thread 1 ending                                                 
 *************************************************************** 
 *********XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX** 
 ***********************                                         
 Thread 2 ending                                                 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXX                                       
 Thread 0 ending                                                 
ͼ

     ६ १ ࠡ  ணࠬ. ᫥ 砭  1- 
ન   , ᫥ 砭 2-   ४
 窨.           㭪樨  DosExit()  c
Action-㬥⮬, ࠢ 0,  ( 뢠,   ⮫쪮 ⥪
      ⠭).  ⥫쭮 짮⥫ , 
 , ⠭  , 㤠 ⠢訥 .

   .                        CHAPTER 5

      ᯮ  ६  ⠪,       㭪
몠  .        㭪,  ⮬᪨ ࠧ頥 ६
 ६묨     ਬ  ࠭祭 ⮩ ,  
ன   ।.ਬ஬   稪 横   ।饩
ணࠬ.

    ६ ⮦ ᯮ  ⠪  ࠧ,    
㭪  C.                   
६,   砫  䠩. ᬮਬ ਬ,   ஬
     , 쭠 ६ alpha,  쭠
६   beta          쭠  ६  gamma 
୥.

/*    thrvars.c     */
/*   ᯮ짮 ६ ﬨ   */
#define INCL_DOS
#include <os2.h>
#include <malloc.h>
#define STACK_SIZE 1024       /*   ࠧ ⥪    */
int alpha = 33;               /*  쭠 ६               */
main()

{
 int beta = 44;               /*  쭠 ६                */
 char far *stkptr;            /*  㪠⥫ ⥪            */
 void far NewTread();         /*  ⨯                   */
 unsigned threadID;           /*  ID -                  */
 unsigned rc;                 /*                           */
                              /*  뤥 ⥪           */
 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

                           /*                */
 if ( rc = DosCreateThread(NewThread, &threadID, stkptr) )
    { printf("DosCreateThread error=%u/n",rc); exit(1); }

 DosSleep( 1000L )            /*  襭 ୥     */
 printf("\nParent knows alpha = %d, beta = %u\n", alpha,beta);
 exit(0);                     /* 砭  ⥩                 */
}
/* NewThread()  */
/*    ⮬    */
void far NewThread()
{
 int gamma = 55;               /*  쭠 ६                */
 printf("\nChild knows alpha = %d, gamma = %d  ", alpha,gamma);
 DosExit(0,0);                 /*  砭 ⮩                  */
}

     ࠡ ணࠬ 㤥 ᫥騩:

       Child Know   alpha=33, gamma=55
       Parent Know  alpha=33, beta=44

     ,   㢨 ,  NewThread() 㭪樥,    .
᫨   ⠥    beta   NewTread()     gamma 
main(),    訡 樨,   ᫨    ᯮ짮
㭪樨.

     饤㯭묨,    ६     㤮
।⢮      裡         ﬨ      .    
⨢ ᫮ । ࠬ஢   ப  (
, ।   吝   ,      㧭
),  室  裡  ᠬ.

        ᯮ짮  ६  ࠧ묨
ﬨ   ⥭樠쭠 誠.  ᪮쪮 ⥩,  믮
६    ६       ६. 
    ⠭  室  न஢     
६   ᥬ஢,   ⮬ .

冷 㯠  ᪮쪨 ⥩.
___________________________________
      뫮  㤮  ᪮쪨 ⥩   
ᯮ짮  짮⥫᪨  㭪樨   .    ਬ,   ணࠬ
ᯮ 2 믮騥 ,    믮 
᫥.      ६ 맢  㭪   ᥭ
⠭   ? 筮 , ᫨ 㭪 ᠭ  ४⭮.
 ᮡ, ᫨ 㭪  ᯮ  ६.

    㭪   ᮧ ᢮ ᮡ⢥ ⥪   
६   ६ 맮.  ⮬, ᫨     ⥩ 뢠
㭪,      ࠧ,      맮  ᮧ  
  ६.  OS/2  ॡ,  ⮡  믮塞    
㥬,  祬 2    믮  ࠧ 
   㭪樨.

    ⥫쭮,  ᫨  㭪  ᯮ  ६,
 ⮫쪮       ⥩,  㯭  㭪樨.
 2,  ਬ,   祭 ६,  ਢ  
砭   1. ⮣  :    ६  , 
   ᯮ짮    㭪樨  ᪮쪨  ﬨ.   ਤ㬠
ਬ,    ஬      㤥  ࢠ.   ⢥न 
।-   ⮬,   㭪   㯭 , 祬
  ६.

       ஦   ୨.    १ 3
⥩    ᨢ  ⠭⠬    뢠  㭪  sum() 
㬬஢  ᮤন  ᨢ.       sum()  ॡ   
権  㬬஢ ᨢ   , , ᮬ, ६
 ६    뢠.

/*    xaccess.c     */
/*   ᯮ짮 ६ ﬨ   */
#define INCL_DOS
#include <os2.h>
#include <malloc.h>
#define STACK_SIZE 1024       /*   ࠧ ⥪    */
#define ARRAY_SIZE 10         /*   ࠧ ஫쭮 ᨢ        */
main()
{
 int far sum(int far *,int);  /*  ⨯ 㭪樨                    */
 char far *stkptr;            /*  㪠⥫ ⥪            */
 void far thread1();          /*  ⨯ 1                      */
 void far thread2();          /*  ⨯ 2                      */
 unsigned threadID;           /*  ID -                  */
 int j;                       /*  稪 横                       */
 int list[ARRAY_SIZE];        /*  ᨢ  ᫥⥫쭮   */


                              /*   ࢮ                    */

 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;
 DosCreateThread(thread1, &threadID, stkptr);

                              /*   ன                    */

 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;
 DosCreateThread(thread2, &threadID, stkptr);

 while( !kbhit() )
 {
     for(j=0; j< ARRAY_SIZE; j++)
         list[j] = 3;
     printf("\nThread 0 calling sum(%d)\n",ARRAY_SIZE);
     if( sum(list,ARRAY_SIZE) != ARRAY_SIZE *3 )
        {printf("Wrong sum\n"); exit(1); }
     printf("\nThread 0 returned\n);

    exit(0);                  /*  ⠭  ⥩                  */
  }

 /*    thread1()  */
 /* 맮 㭪樨 sum()  */
#define ARRAY_SIZE 20
void far thread1()
{
 int list[ARRAY_SIZE];
 int j;
 while(TRUE)
 {
     for(j=0; j<ARRAY_SIZE; j++)
         list[j] = 5;
     printf("\nThread 1 calling sum(%d)\n",ARRAY_SIZE);
     if( sum(list,ARRAY_SIZE) != ARRAY_SIZE * 5 )
        {printf("Wrong sum\n"); DosExit(1,1); }
     printf("\nThread 1 returned\n);
 }

 /*    thread2()  */
 /* 맮 㭪樨 sum()  */
#define ARRAY_SIZE 30
void far thread2()
{
 int list[ARRAY_SIZE];
 int j;
 while(TRUE)
 {
     for(j=0; j<ARRAY_SIZE; j++)
         list[j] = 7;
     printf("\nThread 2 calling sum(%d)\n",ARRAY_SIZE);
     if( sum(list,ARRAY_SIZE) != ARRAY_SIZE * 7 )
        {printf("Wrong sum\n"); DosExit(1,1); }
     printf("\nThread 2 returned\n);
 }


/*    sum()   */
/*   㭪 㬬஢ ᮤন ᨢ   */

int far sum(ptr,n);
int far *ptr;                      /*     㪠⥫ ᨢ      */
int n;                             /*  - ⮢ ᨢ  */
{
 int j;
 int total = 0;
 for(j=0; j<n; j++)                /*   㬬஢ ⮢   */
    total += *ptr++;
    printf("%d/%d ",j, n);

 }
 return(total);                    /*      祭 total */

}

    㭪 sum() 믮  ﭭ     ⥩, ⮣  
㣨 室  .   ਢ ⨯ १.  
   ᥫ,    뢠,    ᨢ
㬬.  ன  뢠  ࠧ୮  ᨢ (⠪  
      ᨢ  ࠧ  ࠧ୮⥩)     뢠
㭪 sum().


Thread 0 calling sum(10)
0/10 1/10 2/10 3/10
Thread 1 calling sum(20)
0/20 1/20 2/20 3/20 4/20 5/20 6/20 7/20 8/20 9/20 10/20 11/20

12/20 13/20 14/20 15/20 16/20 17/20 18/20 19/20
Thread 1 returned
Thread 1 calling sum(20)
0/20 1/20 2/20 3/20 4/20 5/20
Thread 2 calling sum(30)
0/30 1/30 2/30 3/30 4/30 5/30 6/30 7/30 8/30 9/30 10/30 11/30

12/30 13/30 14/30 15/30 16/30 17/30 18/30 4/10 5/10 6/10
7/10 8/10 9/10
Thread 0 returned


      0  ६   ⮫쪮 4- ⮢   10
,०  祬  ࢥ    1,   㬬  20 ⮢
᢮  ࢮ  ᨢ    6  ⮢ ண,  ⥬ 뢠
 2,  㬬 19 ⮢, ० 祬 ࢥ  3.

   ணࠬ    믮  ⮫쪮,  ᪮쪮    (
⢨, 筮, 訡).   來  த஢,
   ⢮ ⥩   ६    㭪
.

    । ࠬ஢ .
-----------------------------

     㦥 ,  ⠭    १  
६.  颠⥫쭮,   ६   ᥣ 
묨   ᯮᮡ.       ॡ   让   ⭮   
ᯮ짮 㭪権 , ⠪  ࠭  祭 ᥣ ,
  䥪⨢  ᯮ   .    몥        
ᯮ짮  ६ ।⢮ । ࠬ⮢:

           func(arg1,arg2,arg3)

     㯨 筮   ﬨ ? । ࠬ஢  
  ⮫  㤮    㭪樨.  ⠪      
ᮧ ⥪  筮  ਤ ""   ⥪  
। ࠬ.

     ਢ ਬ c ।祩 3- ࠬ஢:  楫  
 ᨬ쭮.

/* thparam.c */

/* । ࠬ஢      */

#define INCL_DOS
#include <os2.b>
#include <malloc.h>
#define STACK_SIZE 1024    /* pp ⥪   */


main()
{
 char far *stkptr;         /* 㪠⥫ ⥪     */
 void far tread();         /*                */
 unsigned threadID;        /* ID -                */
 unsigned rc;              /*                   */


                           /* 뤥 ⥪    */

 stkptr = (char far *)malloc(STACK_SIZE) + STACK_SIZE;

 *(stkptr-3) = 1234;       /* ⠢ ࢮ 㬥    */
 *(stkptr-2) = 'b';        /* ⠢ ண 㬥    */
 *(stkptr-1) = 3456;       /* ⠢ 쥣 㬥   */

                           /*                */

 if ( rc = DosCreateThread(thread, &threadID,( char far *) stkptr) )
    { printf("DosCreateThread error=%u",rc); exit(1); }

  DosExit(0,0);             /* 室 ⮫쪮 ⮩        */

}

/*  thread()   */
/*   । ࠬ஢    */

void far thread(intvar1,charvar,intvar2)
int intvar1;
char charvar;
int intvar2;
{
   printf("Intvar1=%d\n",intvar1);
   printf("Charvar=%c\n",charvar);
   printf("Intvar2=%d\n",intvar2);
   exit(0);
}

/* NewThread()  */
/*    ⮬    */

void far NewThread()
{
  while(TRUE)
      printf("-");
}

    ⮩ ணࠬ ࢠ  頥   ⥪ 3  ࠬ,
    㯭  ୨  .  ⥬      
୨. ୨     祭 ६   ⥪ 筮
⠪,   㭪    १:

             Intvar1 = 1234
             Charvar = b
             Intvar2 = 3456

      -ணࠬ   ᫥  ࠬ   (  ᫥    ࠢ)
頥    ⥪    (  孥    ).  ⠫
ࠬ  ᯮ     室饩,  ⮬     ࠬ
ࠧ頥    ⥪  (  ). ⢥⢥, 㪠⥫
㤥 㪠뢠   ⥪ ( ࠬ).


                 
                    
                               㪠⥫,
                              ।  DosCreateThread()
                             <
             /͵   stkptr-1 (3- ࠬ)
           /     3 4 5 6     <
         /    Ĵ   stkptr-2 (2- ࠬ)
                  ' b '      <
              Ĵ   stkptr-3 (1- ࠬ)
                  1 2 3 4     <ĳ
               Ĵ    㪠⥫ 
                                ।  
               ................
       
                            
        \     Ĵ 㪠⥫ ᫥ 뤥
          \                  ⥪ 
            \                <
               ͵
                             
                             

                 
                    


                   . 5-3
       ᯮ짮 ⥪  । ࠬ஢

    ࠣ ணࠬ,  ⠢ ଥ  ⥪:

            *(stkptr-3) = 1234;     /* ࠧ饭 1- ࠬ */
            *(stkptr-2) = 'b';      /* ࠧ饭 2- ࠬ */
            *(stkptr-1) = 3456;     /* ࠧ饭 3- ࠬ */
            stkptr = -3             /* ६饭 㪠⥫  */
                                    /*            設 ⥪  */
      ।  ࠧ  ࠬ  㪠 ᠬ.
᫥ ।  ⠭ 㪠⥫  設 ⥪.

     䥪 ⨣    ⮬ 砥 :

             * -- stkptr = 3456;
             * -- stkptr = 'b';
             * -- stkptr = 1234;

 ,   ⮫ 祢.

   樨  設 몥 㯮冷祭  ⥪  뢠  
ࠡ⪨  ᫮,   ⠬. ⮬ ⥪   ࣠
 ᨢ  楫,    ᨬ.  ⨬,    ਬ  ணࠬ
㪠⥫   ⥪   -   楫    ᫮.     ⥫쭮,    㬥
DosCreateTread() - stkptr -    ਢ  ⨯ char,  
ᯮ  ⮩ 㭪樨. ᫨  ᮧ  㪠⥫ ⨯ char,
  ।饬 ਬ,   㪠⥫  믮 䬥᪨
権: 㬥襭 㪠⥫ ਢ   ६饭  ᫥饬
  ⥪ ,    ᫥饬 ᫮.

   㣨 ᫮, ᨬ ࠬ, । 㭪樨,  
 楫᫥  ⥪,  ᬮ  ,   
 ᫮  ᯮ.

     ⠪      ஥  ᫮  ࠬ஢ ⭮ 
뢠 , ᯮ  ।  ⥪,  ᠭ .

                     

            ⮫쪮  蠡  .    
ਬ xaccess.c ,      ,  ।
  ᪮쪨  ࠫ묨  ﬨ.     뢠  ,   
᪮쪮 ꥪ⮢   ணࠬ  ࠡ    ࠢ.  
ꥪ    ⠬  ,  ⠪   ⮣  ᬨ᪨
ࠡ,    ⥬᪨ ࠦﬨ, 騬 
 쭥襣 襭.

     ਢ  ਬ     ᪠祪,       5   蠤
।   ࠭.   蠤 ।⠢   , 
    ᯮ  騩       ᮬ  蠤.     
    ,  ।    ⥪, ( ᠭ  
।饬  ࠧ).  ६  j  ,  ᯮ㥬  横, 
 蠤,  ⠪ ID ஬ .

     蠤 ।⠢   ࠭    4- ᨬ.  
ࠦ  蠤    쭮  ६,  㯭 ᥬ
.

/* horsrace.c */
/* ਬ ⨭⥩ -  蠤 -   */
#define INCL_DOS
#define INCL_SUB
#include <os2.b>
#include <malloc.h>
#define STACK_SIZE 400     /* pp ⥪   */
#define NUM_HORSES 5       /* ⢮ 蠤      */
#define FINISH_LINE 75     /*              */

char shape[] = "\xDD\xDF\xDD\xDF";

main()
{
 int  far *stkptr;         /* 㪠⥫ ⥪     */
 void far horse();         /*                */
 unsigned threadID;        /* ID -                */
 int j;                    /* ६ 横   */
 struct DATETIME TimeBuff; /*  祭 ६       */
 unsigned rc;              /*                   */


                           /* ⪠ ࠭               */

 VioScrollUp(0, 0, -1, -1, -1, (char far *)&blank, 0 );
 VioSetCurPos( 0, 0, 0);   /* ⠭    孨 㣮*/

                           /* । . 祭 . - */
 DosGetDateTime(&TimeBuff);
 srand( (unsigned)TimeBuff.hundredths );

                            /* 横   蠤   */
 for(j = 0; j<NUM_HORSES;j++)
  {
                             /* 뤥 ⥪  */

 stkptr = (int far *)malloc(STACK_SIZE) + STACK_SIZE;
 *--stkptr = j;              /* j   ࠬ஬   ⥪*/

                             /* c                    */

 if ( rc = DosCreateThread(horse, &threadID,( char far *) stkptr) )
    { printf("DosCreateThread error=%u",rc); exit(1); }
}
  DosExit(0,0);             /* 室 ⮫쪮 ⮩        */

}
/*  horse()   */
/*   । ࠬ஢    */

void far horse(horseID)
int horseID;
{
 int blank = 0x0720;
 int dist = 0;
}



/* NewThread()  */
/*    ⮬    */

void far NewThread()
{
  while(TRUE)
      printf("-");
}

    ᯮ짮 㭪樨   srand()  rand()   祭  
  砩  ᥫ    ᫥⥫쭮  砩  ᥫ.
砫  祭             ᥪ㭤
⥪饣 ६, 砥  DosCreateTread().

     . 5-4   蠤   砭 ᪠祪.

ͻ
                                                      
                          000000                      
                          0   0                       
                             000000                   
                             0   0                    
                                   000000             
                                   0   0              
                                                      
                           000000                     
                           0   0                      
                                                      
                         000000                       
                         0   0                        
ͼ

                . 5-4. 蠤  १ ᪠祪.

      ⠭,ன  蠤  (६  dist)  ॢ
殮 , ᪠窨 稢  蠤, 襤  ࢮ
⠥   襩.      ⢥      ⠪    
⥫쭨楩  뢠  ⠫ .    ⮬ ਬ  5 ⥩
ᯮ 騩 .

      ०    ᯮ짮    横  ⠪ 室 
  樨      맮  㭪樨    ᯮ짮
ࠧ  ࠬ஢      ࢠ  ६  ।⠢
ࠧ 蠤    ।    ࢠ ६.  
䥪⨢  ࠡ  ணࠬ  室  ᯮ짮   ᮡ⢥
஢騪,  뤥騩  ६  ࠡ  㭪樨    蠤 
㣮 ⥬.  ० ᪫砥 室 
"室"    ⨩ 㯭, ⠪    
,   ⮢, ⠭  ᠬ⥫쭮    室
 ࠧ  饭    ணࠬ.   ᠬ⥫쭮
  ᯥ稢          ணࠬ  ⠪
ࠧ   ࠤ  諥 .

    ⥯ ஡  ⮩ ணࠬ  ,   蠤
   ६. ,  ᮧ ࠭,   ᪮쪮
 ६  ࢠ   ᮧ 㣨  . 襭 
஡  ᬮਬ  ᫥ .

᪨ ᥪ樨                                     CHAPTER 5

     砥,  -      易⥫쭮
믮  祭 ண ६.    ,  ⮡
   뢠 㣨.

     ਬ,        ࠢ ஬ ஡,
    ࠧ  ⥪   . ᫨   
㤥 ⠭, ᪠  ६ 饭 㣨 ⥩  ,  
ᯫ ⥪   .  , ᮧ 樮
䥪    ࠭  㦤    த    ﭭ   蠣;
뢠 ⮩  맮 ᪠箪 ࠦ.

      権  OS/2 ।ᬮ७ ⠪ 뢠  ᪨
ᥪ樨.             ᥪ,   뢠
API-㭪 DosEnterCritSec().   ⮬ ⠭ 㣨  .
,맢  㭪, ࠭஢ த 믮  
  ⮬  .    ᪠  ࠡ⪠  稢, 
뢠  㭪  DosExitCritSec(),     믮
㣨 ⥩.

      ਬ  ணࠬ  ᪠    ,     ﭭ
 ન  窨  ࠭.  ⮬  ᯮ
  ᥪ    ⠭  㣨  ⥩.    
멤  ᪮ ᥪ樨, ⠢訥  த 믮.

/* critsec.c */
/* ਬ ᪨ ᥪ権  */
#define INCL_DOS
#define INCL_SUB
#include <os2.b>
#include <malloc.h>
#define STACK_SIZE 1024    /* pp ⥪   */

main()
{
 char far *stkptr;         /* 㪠⥫ ⥪     */
 void far thread1();       /* ⨯     1           */
 void far thread2();       /* ⨯     2           */
 unsigned threadID;        /* ID -                */
 int j;                    /* ६ 横             */

                             /* 뤥 ⥪  */
 stkptr = (har far *)malloc(STACK_SIZE) + STACK_SIZE;

                             /* c ࢮ            */
  DosCreateThread(thread1, &threadID, stkptr);

                            /* 뤥 ⥪    */
 stkptr = (har far *)malloc(STACK_SIZE) + STACK_SIZE;

                             /* c ன             */
  DosCreateThread(thread2, &threadID, stkptr);

  DosSleep( 1000L );         /* 믮  ⥩        */
  DosEnterCritSec();         /* ⠭  ⥩,஬ ⮩*/

  for(j=0; j<10; j++)        /* 砫 ᪮ ࠡ⪨ */
  {
   DosBeep( 200, 3000);      /*  祭 㪮 ᨣ */
   DosSleep(300L);           /*  10 ࠧ                      */
  }
 DosExitCritSec();           /*   㣨 ⥩  */
 DosSleep(1000L);
 exit(0);
}
/*  thread1()   */

void far thread1()
{
  while(TRUE)                 /*   મ            */
       VioWrtTTy("-", 1, 0);
}

/*  thread2()   */

void far thread2()
{
  while(TRUE)                 /*   祪            */
       VioWrtTTy("*", 1, 0);
}

/* NewThread()  */
/*    ⮬    */

void far NewThread()
{
  while(TRUE)
      printf("-");
}

     ਢ   १   ࠡ   ணࠬ.   ᭮   
    ᥪ㭤    㣨      ન  
窨.

ͻ
 --------------------------------------------------------------- 
 ----------------*********************************************** 
 *********************************------------------------------ 
 -------------------------------------------------************** 
 *************************************************************** 
 **----------                                                    
ͼ

    (  ⠭   㪮 ᨣ 10 ࠧ)

ͻ
          ****************************************************** 
 *******-------------------------------------------------------- 
 -----------------------**************************************** 
 ******************************************--------------------- 
 -------------------------                                       
ͼ

    㭪樨   DosEnterCritSec()      DosExitCritSec()   ⭮   
⥩訬  API-㭪;  ࠬ஢      ,      
।, ⨯ void.
Ŀ
       DosEnterCritSec() - ⠭ 㣨 ⥩                  
    DosEnterCritSec(void);                                       


Ŀ
       DosExitCritSec() -  믮 㣨 ⥩  
    DosExitCritSec(void);                                        

    ᪨ ᥪ樨  ⠪  ⫠. ᫨    
-  稭  ᬮ         ⫠  ணࠬ   
᪮쪨 ﬨ,    ⤥   "९"  
㣨,       ⠢  㭪 DosnterCritSec()  㦭
 ⠪,  ⮡ 믮﫠  ⮫쪮 㦭  .    ᫨    ⮬
砥  -    ⠪,      ࠩ     ,   
᫥⢨ ⢨ 㣨 ⥩.

    ᪨  ᥪ樨    ⠪  ᯮ짮  ⮡  
"ᮯ୨⢠ ᫮",஥ 㤥 ᬮ७ .

  ᪨  ᥪ樨    ᫥  ᯮ짮    . 
ਬ, ᫨  ᪮쪮 ⥩  ॡ    ᠬ,  ᪠, 
࠭,          室    ᥪ, ⥬
ᠬ ࠭  㯠  ᠬ ⠫ .  ⠪
  楫ᮮࠧ  ᯮ짮  ᥬ.  ᪨  ᥪ樨
᭨ २⢠  ⨧筮, ⮬     ᯮ짮
⮫쪮  室.

ਮ⠭ ⥩
________________

        ᯮ짮  ᪨  ᥪ樨  ⠭ 㣨
⥩   .   ⠪ ⠭  믮  㣮
.    १砩 ⢨.   ,    
⠭,   ⠭,   ᨬ      㣨,  ⠫
த  믮.  㭪  DosSuspendThread()  ਮ⠭
믮 ,  DosResumeThread() - ந   .

    ਬ 宦   ।騩. ⫨稥  砥    ⮬,
     ⥩ 㤥  ਮ⠭. ᭮   
⠥   -    ࠭,   㤮,  祬   㪮
ᨣ.



/* suspend.c */

/* ਮ⠭   */

#define INCL_DOS
#define INCL_SUB
#include <os2.h>
#include <malloc.h>
#define STACK_SIZE 1024    /* pp ⥪   */

main()
{
 char far *stkptr;         /* 㪠⥫ ⥪     */
 void far thread1();       /* ⨯     1           */
 void far thread2();       /* ⨯     2           */
 unsigned thread1ID;       /* ID -                */
 unsigned thread2ID;       /* ID - p               */
 int j;                    /* ६ 横             */

                             /* 뤥 ⥪  */

 stkptr = (har far *)malloc(STACK_SIZE) + STACK_SIZE;

                             /* c ࢮ            */

  DosCreateThread(thread1, &thread1ID, stkptr);

                            /* 뤥 ⥪    */

 stkptr = (har far *)malloc(STACK_SIZE) + STACK_SIZE;

                             /* c ன             */

  DosCreateThread(thread2, &thread2ID, stkptr);

  DosSleep( 1000L );         /* 믮  ⥩        */
  DosSuspendThread(thread1ID); /* ⠭ 1              */
  printf("\nSuspending thread 1\n");

  for(j=0; j<160; j++)       /*  -                  */
   printf("X");
   printf("\nResuming thread 1\n"); /* ⠭  1 */
   DosSleep( 1000L);         /*  믮  ⥩       */
   exit(0);                  /*  室  ⥩              */
  }


/*  thread1()   */

void far thread1()
{
  while(TRUE)                 /*   મ            */
       printf("-");
}

/*  thread2()   */

void far thread2()
{
  while(TRUE)                 /*   祪            */
       printf("*");
}


           ୨    믮, 
 室             祭      ᥪ㭤.    ⥬
  "஡㦤",  ࢠ      ⠭  (   ⠥
ન), ⠥       -   ,      ()
ࢠ     ⥫쭮  頥     ﭨ    
祭 ᫥饩 ᥪ㭤.

       㭪,  ࢠ   믮, ન 
,    த ⠢ 窨,   
 ⠥  -.


ͻ
                                                                  
 ---------------------------------------------------------------  
 ------------***************************************************  
 *****************************----------------------------------  
 ----------------------------------------------*****************  
 ***************************************************************  
 ***----------------                                              
 Suspending thread 1                                              
 XXXXXXXXXXX**************************************                
 *****************************************XXXXXXXXXXXXXXXXXXXXXX  
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX************  
 ***************************************************************  
 *******XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
 XXXXXXXXXXXXXX                                                   
 Resuming thread 1                                                
 ***************************************************              
 ************************---------------------------------------  
 ----------------------------------------***********************  
 *********************************************************------  
 --------------------------------------------------------------   
 ----------------***********************************************  
ͼ



       DosSuspendThread() - ⠭ 
Ŀ
   DosSuspendThread(threadID);                                   
   unsigned threadID;       /*  ID- ⠭   */

       DosResumeThread()  -  
Ŀ
   DosResumeThread(threadID);                                    
   unsigned threadID;       /*  ID- 塞    */

    DosSuspendThread()       DosResumeThread()      ⮫쪮  
ࠬ:   䨪  ,          ⠭
().  - 頥 ࠬ 㭪樨 DosCreateThread().

      ⠭  ᠬ ᥡ. ⥫쭮, ᫨  
 ⠭,   "ᠥ".

室  ᯨ᪨.
-----------------

      砥       樮 ⥬ ⨯
MS-DOS,        ணࠬ    蠥    ०६,   ࠭
।ᬮ७  ଠ쭮   襭.  ਬ,   짮⥫,
ࠡ    ⥪⮢  ।,       㬥. ᫨
짮⥫  멤    ணࠬ  樥  [Ctrl][C],     
  㭨⮦ ०, 祬 䠩 㤥 ᠭ  .

      ⨧  ⥬  ஡  ०६ 襭
   쥧, ⠪  ணࠬ   ࢠ 
⮫쪮   㪠   樥,         㣨  ணࠬ  
஢騪  ᥠ.    ⮬      쬠 ⥫쭮  窨
७  室  ᮢ.     ॡ ᢮
ᥬ,  ᥣ   ,  ,   ।     稥  ,
ᯮ㥬 ᪮쪨 ᠬ.

    ⥫쭮 ᮧ  ணࠬ,   "।" ஧饥
襭   ᫥   맢 㦥 㭪樨.  OS/2
ॠ ⠪  ⥬ ᯮ짮 室 ᯨ᪮.  
ᯨ᮪  ᮢ   ணࠬ,     ।  ࠢ   
襭 ண .

    ନ஢  室  ⠡  ⢫      API -
㭪樨 DosExitList().   㭪  ᯮ   3-   ࠧ묨
ᯮᮡ.:   饭   ணࠬ   室 ᯨ᮪.
      ணࠬ  ६ 樠樨.   ⢨
砥    ᮮ饭    :"蠩,  ᫨       -
,  믮     ᫥⥫쭮   (蠡)".  ன    :
DosExitList()  㤠   室 ᯨ᪠.   
    믮    ᫮,  易   ⢨
ணࠬ   - ਬ,᫨ ணࠬ 믮 ᢮  ,
।  ࠢ  ᫥饬 襭 ᫠.

     ⨩  砩,    ணࠬ    室  ᯨ᪠ ᠬ
뢠  DosExitList(),   ᮮ  樮   ⥬      ᢮
襭,    ᯮᮡ  室   ᯮ    exit()   
DosExit().

     ਬ    ਬ 㭪樨.

/* exitlist.c */
#define INCL_DOS
#define <os2.h>
#define <malloc.h>
#define ADD_ADDR 1         /*    .ᯨ*/
#define DONE 3

main()
{
 void far exit1();         /* ⨯ . -        */
 void far exit2();         /* ⨯ . -                             */
 unsigned rc;              /*                   */

                           /* ⠭ ࢮ . ᯨ᪠*/

 if ( rc = DosExitList(ADD_ADDR,exit1) )
    { printf("DosExitList error=%u/n",rc); exit(1); }

                           /* ⠭ ண . ᯨ᪠*/

 if ( rc = DosExitList(ADD_ADDR,exit2) )
    { printf("DosExitList error=%u/n",rc); exit(1); }

 while( !kbhit() )         /* 室        */
    printf("X");
 exit(0);                  /* 뢠  ⥩        */

}


/* exit1()      */
/* ࢠ ᫥⥫쭮,믮塞  室  */

void far exit1()
{
  unsigned rc;
      printf("\nClearing flags and semaphores");
      if( rc=DosExitList( DONE, 0L ) )
      printf("DosExitList error=%u\n,rc");
}

/* exit2()      */
/*  ᫥⥫쭮,믮塞  室  */

void far exit2()
{
  unsigned rc;
      printf("\nFreeing resources");
      if( rc=DosExitList( DONE, 0L ) )
      printf("DosExitList error=%u\n,rc");
}

      ਬ  ନ    ணࠬ  -  exit1()  exit2(). 
ଫ      㭪権  ,    ࠡ  ᪮쪮  . 
।    ࠢ  ॥,  祬  뢠 ணࠬ; 
ࠢ ந室   ⠪     㭪権,   १ 㭪
DosExitList().  ⮬  ,  ᮤঠ騩     ⠫.
ࠢ । ।⢥ .

   㭪  DosExitList()      ࠬ.    -    
㭪樨, ਭ騩 ᫥騥 祭:

   祭          㭪

     1           室 ᯨ᮪, 㪠  ஬ ࠬ
              
     2           室 ᯨ᪠ , 㪠  ஬
               ࠬ
     3         ᯮ  襭 ᠬ ணࠬ 室

        祭  ਬ    祭  (᪫祭) 
室  ᯨ᮪   ,  㪠     ஬   ࠬ.  ᫨
ᯮ  祭,  ன ࠬ  ᯮ,  
⮬ 祭 㪠⥫  NULL,  0L.

   DosExitList(FnCode,Address); 
Ŀ
   unsigned FnCode;           /*  1 -   室 ᯨ᮪  */ 
                              /*  2 - 㤠  室 ᯨ᪠ */ 
                              /*  3 - 室                       */ 
                                                                     
   void(far *)(void);         /*   ணࠬ ࠡ⪨ 室*/ 

    ணࠬ ࠡ⪨ 室  襯ਢ ਬ  
᢮ ᮢ  믮 㣨 "樮"  .
  ᥣ    ⭮  ନ     ᢮ ⢨, 
ᮮ⢥騥 ᮮ饭,   ७  ࠧ ⫨砥    
⨪.

        ணࠬ,  頥    ࠭  
-.  짮⥫  ࢠ 믮,     
(  ⮬  믮  㭪   exit()).    ਢ   १
믮 ணࠬ.

ͻ
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX                              
 *********************************------------------------------ 
 Clearing flags and semaphores                                   
 Freeing resources                                               
 C>                                                              
ͼ

     ⮫쪮 室 ᯨ᮪  稢, ࠢ 頥  .
    ࠢ । 室 ᯨ  ⠪  뢠 樨
[Ctrl][C],    ᫥饬 ਬ:

ͻ
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX                              
 *********************************------------------------------ 
 Clearing flags and semaphores                                   
 Freeing resources                                               
 The process has stopped                                         
 the process was cancelled either by itself,                     
 another process, or by pressing Ctrl+Break                      
 C>                                                              
ͼ

     믮 㭪樨 DosKillProcess() 㣨 ᮬ   
१.
     ॠ ᫮ ᯨ᮪ 室    ७ 
襭  쥧  .      祭   ᮢ
裡,  ⨬ ⢮ 権,    ਬ  室
ᯨ᪮  쬠 .

  .
_________________________


    蠥      ᬮ७   ᪮쪮  
ਬ஢  ணࠬ.    ਬ   ।⠢  ᯮ짮
⥩    ॠ  ணࠬ    㪠뢠  ⥭樠  ஡,
蠥      ᥬ஢,    祬  㤥 ᪠  ᫥饩
.

⥭    

      譥   㯠   ॥,  祬
ணࠬ   ࠡ.    ⥫쭮,  ⮡
㯠騥        ,         
ﭠ.

      ਬ஬  ⠪  樨    ᨬ. ᫨
짮⥫ 뫠 ᨬ ॥, 祬    饭  
࠭,      ᨬ  ⭮  .  ᯮ짮
⨧筮 ⠪ ஡ ⠪  , ⠪  㣨
  ࢠ  뢠/⮡ࠦ   ६
뫪 ᨬ   ࠦ.

    襭 ஡    ,   
ᨬ  ०,  祬         ࠭.       蠡,
뢠騩 ᨬ      蠡,  騩    ࠭,
ࠡ ᨭ஭,        ᯮ짮 ࠧ  .
""    ᨬ      頥    , 
""    ᨬ   ,  ⮫쪮  室,
頥    ࠭.   ⮬  砥,    뢠
 뢠  ⮡ࠦ ᨬ, ଠ  .

     뢠,     㪠⥫  .  ⥫
뢠饩   㢥稢    頥  ᨬ   .
⥫  饩    㢥稢  ᫥  ⮡ࠦ ᨬ 
࠭.   㪠⥫ ६      ﭨ  
 뢠, ᪮쪮 ࠦ ᨬ ⠥  . 
 ࠦ  㭪 5-5.




    ⮡ࠦ      writeptr
   /- - - - - - \  
  \
   N  O  W    I  S     T  H             /
  \
  \- - - - - - - - - - - - - - - - - / 
                                
                                        readptr


                   . 5-5

     ந ᫨  ९ ?   襭 
殢뢠  ,    ஬      "ᮥ" 
砫.    ணࠬ  ᬠਢ ⥩訩  砩,  
    㪮  ᨣ. 直  ࠧ  
⠥      ,  ⠪  ࠧ, 㪠⥫  ⥩
६  砫 .  ⠪,   㪮  ᨣ 
⮩ ,  室         
 . ᫥ ⮣ ࠡ  㤥 த.

/* readwrit.c */
/* 1-  뢠   ,  oࠦ   ࠭ */

#define INCL_DOS
#define INCL_SUB
#define <os2.h>
#define <malloc.h>
#define STACKSIZE 1024     /* pp ⥪   */
#define ARRAY_SIZE 50      /* ࠧ ᨬ.      */
#define HANDLE 0           /* -  ࠢ 0*/
#define WAIT 0             /* 0-, 1 -     */
#define FREQ 1000          /*  㪠           */
#define DURATION 100       /* த⥫쭮 㪠 */
char charbuff[ARRAY_SIZE]; /* ᨬ.              */
char *writeptr;            /* -             */
char *readptr;             /* -             */
main()
{
 struct _KBDKEYINFO keydata; /**/
 char far *stkptr;         /* 㪠⥫ ⥪              */
 unsigned writerID;        /* ID -                */
 void far writer();        /**/
 readptr = charbuff;       /* ⠭ 㪠⥫         */
 writeptr = charbuff;      /* 砫                 */

                           /*  "饩"          */

 stkptr = (char far *)malloc(STACKSIZE) + STACKSIZE;
 DosCreateThread(writer, &writerID,  stkptr) ;
 while( TRUE )
   {
    KbdCharIn( &keydata, WAIT, HANDLE );
    if (readptr < charbuff + ARRAY_SIZE )
       *readptr++ = keydata.chChar;
    else
       DosBeep( FREQ, DURATION);
    }
}

/* writer()     */
/* ⮡ࠦ ᨬ  ࠭*/

void far writer()
{
  while(TRUE)  {
      if ( writeptr < readptr) {
         VioWrtTTy(* writeptr++, 1, HANDLE );
        if (writeptr == readptr )
            writeptr = readptr = charbuff;
         }
    DosSleep(200L);
 }
}

      稫   প  200          ,   
ᯮᮡ  ணࠬ  ࠢ  ⪮.  ⨬  ணࠬ  
⠥    ࠧ    ࠭.    㤥    ०
ࠦ. ᫨   ४  ,   ࠦ 㤥 
. ᫨      ०, 祬    
   ६ ᨬ  (⠩   50 ᨬ),  
 㪮 ᨣ.  室  ணࠬ  [Ctrl][C].

     ᭮ ணࠬ   charbuff[]   㪠⥫  readptr
 writeptr.  㪠⥫  樠  砫 .  
  砥  ᨣ      㭪樨  KbdCharIn(),    
 KBDKEYINFO  charbuff   㢥稢 㪠⥫ readptr.  
⠪  ஢,  ⨣    㪠⥫    .  ⮬ 砥
ࠧ 㪮 ᨣ  ९ .

      ஢,   㪠⥫ writeptr 祬  readptr.
᫨ ,   砥,      ⮡ࠦ  ᨬ 
⠥       ,    ⥬   㢥稢  writeptr.   
஢,  ࠢ    㪠⥫.   ࠢ⢥   㪠⥫
  砫 .

஡ ᮢ ᨭ஭樨.
______________________________________

     ⥭樠쭠 ஡,     ணࠬ
 ᫮ ⨧筮.

   ।,        ⮫쪮  ஢ ࠢ⢮ 
㪠⥫      ।    祭.   ।, 
    ⠭  5-  .   ᫥饬
ࠣ   ணࠬ          믮 ࢮ  ப:

  if (writeptr == readptr)               /*        ᫨ ࠢ        */
      writeptr = readptr = charbuff;     /*  ६ 㪠⥫ */

       ⠭ 㪠⥫  砫 charbuff, ᯮ
 ப.    , ०  祬  㤥  ᤥ,६
,  뤥  饩       ࠢ 墠
 .    㦨 ᨬ     頥
     5-  樨  .     ࠢ  砩 ࠧ
। 饩 ,  த  ⮣  ,   ஬
  ࢠ  ᢮  ࠡ    ६頥  㪠⥫   砫 
charbuff.   ᨬ 㦥  ,  ய饭  ⮡ࠦ   5-
樨,         砫 .  宦 
 ப!

     樤,  ⭮,   祭 .   砥, 
     ଠ   饩     ⮬
஢騪 ᠬ⭮  । ࠢ       㣮.
 襣  ᬮ७ ⮩  ஡ ᥬ  প   
 ᪨ ।ﬨ  㥬  .


/* writer.c */
/* ⮡ࠦ ᨬ    ࠭ */
void far writer()
{
  while(TRUE)  {
      if ( writeptr < readptr) {
         VioWrtTTy(writeptr++, 1, HANDLE );
        if (writeptr == readptr )
          {
            DosSleep(200L);
            writeptr = readptr = charbuff;
           }
         }
    DosSleep(200L);
 }
}
     ⨬ 䨪ﬨ ணࠬ 㤥  ࠡ ଠ쭮, ᫨
 㤥  祭  , ᫨     㤥
ﭭ  ॥,  祬  ⮡ࠦ    ࠭.  ᫨ ⮡ࠦ
㤥    ,    ᨬ    .  
DosSleep()  ᨬ  ⮦  ,     ᪮쪮  ०,  ⠪   
㬥蠥  ⭮   뢠  饩          
㯮묨 ﬨ.

    뢠 ᯮ⢮      ணࠬ,   ஢  
⠭  㪠⥫  -    ⮬   ⨬ 뢠
㣨 ﬨ.  ,  ன  믮 ணࠬ 
  筮  ᨭ஭樨    ࠧ  ⥩,뢠  
᫮.  ணࠬ    ᫮  ஡    
 砥        .    䥪 㫮
ᮡ 㤭:   ᭮  ᭮ ᬠਢ ணࠬ   
  訡.  쭮  ⠪  䥪    ࠩ ।,
    㭪樮஢ ணࠬ ਥ.

    ࠫ:    ᫮   蠩  ஡  
ᥬ஢,  ᪨  ᥪ権    ... ⥩.  ᯥ稢
  饥      襭.    ᫥饩    㢨 
ਬ    ᥬ஢    ᫮.

  騩  ਬ    饥  ।⠢   ⮬,   
ᯮ짮    ண  믮 ணࠬ.    ணࠬ
।       ᫠       ᫥⥫쭮,    
짮⥫.    ࠭    ᨬ 㯭
᫨⥫ ,  ॡ騩 ⥫쭮  ६    
ࠡ⪨ .

    ࠤ樮 筮 樮 ।  ணࠬ  
  ᠭ   筮 横,    㭪 5-6.




               Ŀ
                                  
    Ŀ        
                             
                                 
            
    Ŀ        
        믮               
        ᫥               
            
    Ŀ        
                           
         १⮢             
            
                                  
               

          . 5-6

    짮⥫   ᫮   ⥬    ணࠬ ।
⮥    .  ।  ⨯  ᫠    ६, 
᪮쪨 ᥪ㭤,  ᨬ  ⨯ .

     ணࠬ ࠦ  室.
/*  prime.c  */
/* ।  ᥫ  */
#define TRUE 1
main()
{
 unsigned long div,number;
 unsigned long isprime(unsigned long);

 while(TRUE)
  {
   printf("\nTnter an integer :")  ;
   scanf("%u", &number);
   if ( div=isprime(number))
     printf("\lu is divisible by %lu\n", number, div);
   else
     printf("%lu is prime\n", number);

  }
}


/*  isprime()  */
/*  return 0 if argument is prime, divisor is not */

unsigned long isprime(unsigned long number)
{
 unsigned long j;
 for (j=2; j<number; j++)
    if(( number % j) == 0)
     return(j);
  return(0);
}



     ⮤ । ⨯ ᫠   ,   .
 ⮩  ணࠬ ᠬ  ᫮      楫,  . ᫨
⮪   ࠢ ,   ᫮   ⮥.  㭪 isprime()
頥 0 , ᫨ ᫮ ⮥  ⥫  ⨢ 砥.

        奬  ᫥,   ᫨  ⠭  横   
宦  ⥫,     ண     室    ᫠
 (⠪,ਬ,  ஢થ ᫠  100  ᫠ ஢  ⥫
  10).  ஬  ⮣,  祢,    ᫠ ஢ 
᫠.  ࠧ, 襩 楫   ࠧࠡ⪠  䥪⨢
⮤ ᪠  ᥫ,  ᫥ ⨧筮.

    ᯥਬ   ᫠  ⠭ ᥪ㭤 ᫥.
஢,    ᫠  33331,  77771    99991 묨. 
訥 ᫠,    ᯮ짮   80286, প
㤥  ⨬.    (⢥,          
஢ ᫥ ⥫쭮 ॥,  ⮬ 砥 㦭   
訥 ᫠ :  333331). ⨬,     ᥫ  ॡ
浪 2 :   ᥪ㭤   ᫠       .
  ६, ᫨ ஢  樨 ࠫ쭮.

    ணࠬ rewrite1.c   ࠡ  ⨧筮  ०.
  ᯮ    㬥 ᨢ.

    ࢠ  樠   ⥬ 稭 横,  ஬
뢠    짮⥫  ᫠    뢠   
 ᨢ. 짮⥫ ४頥  ᥫ,  0.   ⮣
 ࢠ   稭   १.  ᫨ १ 㦥
  ,   뫠  饥 ன⢮,   ⨢
砥   "㯫"  .

      뢭 ஢,    ᨢ ,  ᫨ ,
  롨ࠥ  ᫮      .    (⥫  0)
    ᨢ. ᫨  ࢮ ⮫ ᥫ  ,
    室    ﭨ  .    㭪 5-7 
㭪樮஢  ⥩.




                                          ᫥

Ŀ
                -----------------------Ŀ
     ன                              |
                        |
Ŀ                        |
                 <Ŀ               |
                                            |
                       |
Ŀ                       |
  ᥭ  ᯨ᮪                        |
                                            <Ŀ
                                          
                                                                
                                                                
          / \                                / \                  
        /     \                            /     \                
      /         \                        /         \              
    /         \                 /    ᯨ᮪   \          
  /                 \      /                 \>
   \   襭 ?   /                  \            /          
     \            /                      \            /            
       \        /                          \   ?    /              
         \    /                              \    /                
           \/                                  \/                  
         <Ŀ                               
                                                                
          / \                                                    
        /     \                     Ŀ       
      /         \                        ᫥             
    /   ᫠   \                                          
  /               \  >            
   \          /                                            
     \            /                                              
       \        /                              
         \    /                
           \/                  
                              
                            
Ŀ        
                       
                             
        
                              
                              
           


                           5-7




     짮⥫  , ணࠬ   ।騩
.     ६,   ⠥ १, ணࠬ  ࠡ뢠
᫥騥 ᫠.  ᪨   3 :  , ᫥  
뢮.  ⮡  ⠪  ᮢ饭  /뢮    ࠭     ⠫
짮⥫,  ࠧ᫨  樨  뢮 १⮢  稭
᫥ 砭  .

     ணࠬ 宦   ணࠬ rewrite.c,  ன  ࠧ
  㫨      ஬.  ⥫쭮,     prime2.c
䠪᪨  3  樨  -  ⥭,    ⮡ࠦ ॥, 祬
⮫쪮 ⥭  ⮡ࠦ  rewrite.c.



/* prime2.c    */

/* 1-  뢠  ,  oࠦ  ࠭ */

#define INCL_DOS
#define <os2.h>
#define <malloc.h>
#define STACKSIZE 1024     /* pp ⥪   */
#define ARRAYSIZE 50       /* ࠧ ᨬ.      */

unsigned long number[ARRAY_SIZE][2];  /* ᨬ.   */
int index=0;
int caldex =0;

main()
{
 int outdex;
 char far *stkptr;         /* 㪠⥫ ⥪              */
 unsigned rc;
 unsigned writerID;        /* ID -                */
 void far calc();          /*  ⨯ ன         */


                           /*  "饩"      */

 stkptr = (char far *)malloc(STACKSIZE) + STACKSIZE;

  if ( rc = DosCreateThread(calc, &threadID,  stkptr));
     { printf("DosCreateThread error=%d",rc); exit(1);}

                            /*  ᥫ,  ᨢ*/

   printf(" Enter possible primes, terminate list with 0.\n");
   for(index=0; index<ARRAYSIZE; index++)
  {
      printf("Enter an integer :");
      scanf("%u",&number[index][0]);
      if (number[index][0]==0L)
      break;
   }
   while( TRUE )
   {
    if(outdex == calcdex && calcdex==index)
       exit(0);
    if (outdex < calcdex)
    {
      if( number[outdex][1] )
        printf("%lu is divisible by %lu\n"
          number[outdex][0], number[outdex][0]);
       else
        printf("%lu is prime\n", number[outdex][0]);
        outdex++;
     }
     else
        DosSleep(0L);
   }
}

/*  calc()   */
/*  ᥭ 0  ᨢ, ᫨ ᫮ ⮥  */

void far calc()
{
 unsigned long isprime(unsigned long);
 while(TRUE)  {
   while( index <= calcdex )
       DosSleep(0L);
        number[calcdex++][1] = isprime(number[calcdex][0]);
    }
 }

/*  isprime()  */
/*  頥 0 , ᫨ ᫮ ⮥   */

unsigned long isprime(unsigned long number)
{
  unsigned long j;
  for( j = 2; j< number; j++)
    if((number "%j) ==0)
       return(j);
  return(0);
}

      ⮩  ணࠬ  㪠⥫  index    caldex,   
묨 ६묨, ⬥   ᫥饩   
.  쭠  ६  outdex  ⮡ࠦ  ᫥  
뢮.  㭪 5-8     㪠⥫  砫,  
६   ⥬  砭 뢮.



            Ŀ
                               
  > Ĵ
             3 9 2 0 3               
            Ĵ
             3 0 0 1 3               
            Ĵ
             3 5 3 5 3          0      caldex
            Ĵ <
             7 0 0 3 3        5 9    
            Ĵ
             2 3 3 3 3          0    
                                     
            
                   


    
   >Ŀ
                                   
             7 9 9 9 9             
            Ĵ    calcdex
             2 0 0 1 1             <
            Ĵ
             3 9 2 0 3      1 9 7  
            Ĵ
             3 0 0 1 3          0  
            Ĵ    outdex
             3 5 3 3 3          0  <
            Ĵ
             7 0 0 3 3        5 9   \
            Ĵ  I printed
             2 3 2 3 3          0   /
            


                      뢮


            . 5-8  㪠⥫  ணࠬ prime.c




    ᫨        ᯨ᮪  ᥫ,      ணࠬ 
॥, 祬  筮 ०.   , 設 㬠.

஡ ࠤ ६ .              CHAPTER 5

      ⮬  ਬ     ஡  ⠫  ஭⮩.   
襭 ⮥ ࠢ ணࠬ஢  ⨧筮 ०:  
  砭  横.      横   設 ⠪,
   ᯮ짮 㣨 ﬨ  ᠬ.   ⮬
ਬ   ࢠ    ६   १⮢  ࠡ⠥   while
横  ,         १⮢ ᫥.  ,
ᯮ㥬    ᫥,      㣮  while  横   
,   ᫥  室 .

     横   ࠢ ⥬     DosSleep()
 㦨,  祣  .     ࠢ
।  ⮫쪮       ६  .  ஢騪   
१ࢨ஢  ⠪    ᮢ ᨬ   ⮣, 
   ࠡ   . ⮬   ࣠樨  横  
ᯮ짮  樨,   騥         믮
᫮  ।  ࠢ      ,      ᫮  
믮.

    襭  ⮩  ஡    ஡  ᨭ஭樨   ।饬
ਬ,  ᯮ짮 ᥬ஢,   ᬮ७ 
᫥饩 .

㣨 ਬ ⥩.
________________________

          ਬ  ?  ணࠬ  horse.c
,        ᯮ짮    饭  
ணࠬ.   ணࠬ  prime2.c    ਬ  ⥩  
ᯠࠫ /뢮.  ⠪   ᯮ짮 
믫  㦥  㭪権, ᨬ   짮⥫᪮
.    ਬ,  ⥪⮢  ।  ਮ᪨ 뢠
ᮤন  䠩        ⥬  ᠬ  ࠭  ଠ  
 ⪫祭 設. ⤥   ᫥ ६  
஢      ⥫⢠  짮⥫.    ᭮ 
뢠   ணࠬ   祣-.     
,    ६,   㣨   믮   ࠡ. 
⥫㭨樮 ணࠬ    ,  㯠騥
  㣮  ନ,      ࠦ   ࠭, 
᫥  짮⥫.    ᫥  ᮮ饭ﬨ,
㯠騬  㣨 ᮢ १  ᮢ  .
  ⮬  砥         ᯮ  ᫥
ᮮ饭  㣨 易  짮⥫.

              

      ⮩      㦤  ᯮ짮  ⥩,㭪樮쭮
।⢮ 筮   OS/2.  稫      ஦
㣨      DosCreateThread(),    ࢠ     
DosExit(),   ࠣ 㣨  ,    ᮢ⭮  ᯮ
 ६.   ஢ਫ  ࠧ   
६    樨 ,  ᪮쪮 ⥩ ᯮ
騥   ணࠬ    ।  ࠬ     
⥪.

      ⨫    ᪮쪮  API-㭪権,  易     ﬨ.
᪨ ᥪ樨,        ஬  ⠭,
ᮧ       DosEnterCritSec()     㤠   ।⢮
DosExitCritSec().           "஦"     
DosSuspendThread()    ⠭        DosResumeThread().
᫥⥫쭮  権,         믮   
뢠 ணࠬ ᮧ  "ࠢ" DosExitList().

     襭    ᬮ५   ਬ ਬ ⥩  
஬        ணࠬ     ᥫ. 
ਬ    ॡ    ⥫쭮 堭 ᨭ஭樨
⥩.     ᥬࠬ  ᫥饩 .