DosGetPrty

#define INCL_DOSPROCESS

USHORT  rc = DosGetPrty(Scope, Priority, ID);

USHORT           Scope;         /* Indicate scope of query */
PUSHORT          Priority;      /* Address to put priority (returned) */
USHORT           ID;            /* Process or thread ID */

USHORT           rc;            /* return code */

Example 

The following example illustrates how to obtain the priority of a thread 
and how to change the priority.  The main thread creates Thread2 and 
allows it to begin executing.  Thread2  iterates through a loop that 
prints a line and then sleeps, relinquishing its time slice to the main 
thread. After one or two iterations by Thread2, the main thread obtains 
Thread2's priority information and prints it.  It then raises Thread2's 
priority to fixed-high, and increments the level by ten.  Since Thread2 is 
now at a high priority, it immediately finishes its remaining iterations 
before relinquishing control on a long sleep; at this point, the main 
thread re-examines Thread2's priority and reports its new priority level. 
 In this example, it is helpful to understand how the DosSleep calls are 
used either to relinquish control of the processor, or to keep a thread 
alive (see DosTimerAsync or DosTimerStart for alternatives to DosSleep). 

#define INCL_DOSPROCESS

#include <os2.h>

#define      PRTYC_FIXEDHIGH   4         /* Priority class: fixed-high */
#define      PRTY_DELTA        10        /* Priority delta: increase
                                                by 10 */
#define      SEGSIZE           4000      /* Number of bytes requested in
                                             segment */
#define      ALLOCFLAGS        0         /* Segment allocation flags - no
                                             sharing */
#define      SLEEPSHORT        0L        /* Sleep interval -
                                             5 milliseconds */
#define      SLEEPLONG         20L       /* Sleep interval -
                                             75 milliseconds */
#define      RETURN_CODE       0         /* Return code for DosExit() */


VOID APIENTRY Thread2()
{
  USHORT     i;

  /* Loop with four iterations */
  for(i=1; i<5; i++)
  {
    printf("In Thread2, i is now %d\n", i);

    /** Sleep to relinquish time slice to main thread **/
    DosSleep(SLEEPSHORT);          /* Sleep interval */
  }
  DosExit(EXIT_THREAD,             /* Action code - end a thread */
          RETURN_CODE);            /* Return code */
}

main()
{
  USHORT     Priority;            /* Thread priority */
  USHORT     Class;               /* Priority class */
  USHORT     Level;               /* Priority level */
  SEL        ThreadStackSel;      /* Segment selector for thread stack */
  PBYTE      StackEnd;            /* Ptr. to end of thread stack */
  USHORT     rc;

  /* Allocate segment for thread stack; this is better than just */
  /* declaring an array of bytes to use as a stack.  Make pointer eos. */

  rc = DosAllocSeg(SEGSIZE,                    /* Number of bytes
                                                   requested */
                   &ThreadStackSel,            /* Segment selector
                                                   (returned) */
                   ALLOCFLAGS);                /* Allocation flags */
  StackEnd = MAKEP(ThreadStackSel, SEGSIZE-1);

  /* Start Thread2 */
  if(!(DosCreateThread((PFNTHREAD) Thread2,    /* Thread address */
                       &ThreadID,              /* Thread ID (returned) */
                       StackEnd)))             /* End of thread stack */
    printf("Thread2 created.\n");

  /** Sleep to allow Thread2 to execute **/
  if(!(DosSleep(SLEEPLONG)))                       /* Sleep interval */
    printf("Slept a little to let Thread2 execute.\n");

  /** Obtain Thread2's priority information and report it **/
  if(!(rc=DosGetPrty(PRTYS_THREAD,                /* Scope - single
                                                         thread */
                     &Priority,                   /* Address to put
                                                          priority */
                     ThreadID)))                  /* ID - thread ID */
  {
    /* Extract priority class and level information */
    Class = HIBYTE(Priority);
    Level = LOBYTE(Priority);
    printf("Thread2: ID is %d, Priority Class is %d and Level is %d\n",
           ThreadID, Class, Level);
  }
  /** Raise Thread2's priority **/
  if(!(rc=DosSetPrty(PRTYS_THREAD,             /* Scope - single thread */
                     PRTYC_FIXEDHIGH,          /* Prty class - fixed-high */
                     PRTY_DELTA,               /* Prty delta - increase
                                                      by 10 */
                     ThreadID)))               /* ID - thread ID */
  {
    /* Obtain Thread2' new priority information and report it */
    rc=DosGetPrty(PRTYS_THREAD,                /* Scope - single thread */
                  &Priority,                   /* Address to put
                                                       priority */
                  ThreadID);                   /* ID - thread ID */

    /* Extract priority class and level information */
    Class = HIBYTE(Priority);
    Level = LOBYTE(Priority);
    printf("Thread2: ID is %d, New Priority Class is %d and Level is %d\n",
           ThreadID, Class, Level);
  }
}