path: root/files/ja/mozilla/projects/nspr/reference/introduction_to_nspr/index.html

---
title: NSPRのイントロダクション
slug: Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR
translation_of: Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR
---
<section id="Quick_Links">
<ol>
  <li><a href="/ja/docs/Mozilla/Projects/NSPR">NSPR</a></li>
  <li><a href="/ja/docs/Mozilla/Projects/NSPR/About_NSPR">About NSPR</a></li>
  <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference">NSPR API Reference</a></li>
  <li><a href="/ja/docs/Mozilla/Projects/NSPR/NSPR_build_instructions">NSPR Build Instruction</a></li>
  <li><a href="/ja/docs/Mozilla/Projects/NSPR/Release_process">NSPR Release Process</a></li>
  <li class="toggle">
    <details open>
      <summary>Introduction to NSPR</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#NSPR_Naming_Conventions">NSPR Naming Conventions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#NSPR_Threads">NSPR Threads</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Thread_Schedoling">Thread Scheduling</a>
              <ol>
                <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Setting_Thread_Priorities">Setting Thread Priorities</a></li>
                <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Preempting_Threads">Preempting Threads</a></li>
                <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Interrupting_Threads">Interrupting Threads</a></li>
              </ol>
            </li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#NSPR_Thread_Synchronization">NSPR Thread Synchronization</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Locks_and_Monitors">Locks and Monitors</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#Condition_Variables">Condition Variables</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Introduction_to_NSPR#NSPR_Sample_Code">NSPR Sample Code</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>NSPR Types</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Calling_Convention_Types">Calling Convention Types</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Algebraic_Types">Algebraic Types</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#8-.2C_16-.2C_and_32-bit_Integer_Types">8-, 16-, and 32-bit Integer Types</a>
              <ol>
                <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Signed_Integers">Signed Integers</a></li>
                <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Unsigned_Integers">Unsigned Integers</a></li>
              </ol>
            </li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#64-bit_Integer_Types">64-bit Integer Types</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Floating-Point_Number_Type">Floating-Point Integer Type</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Native_OS_Integer_Types">Native OS Integer Types</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Miscellaneous_Types">Miscellaneous Types</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Size_Type">Size Type</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Pointer_Difference_Types">Pointer Difference Types</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Boolean_Types">Boolean Types</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Types#Status_Type_for_Return_Values">Status Type for Return Values</a></li>
          </ol>
        </li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Threads</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Threading_Types_and_Constants">Threading Types and Constants</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Threading_Functions">Threading Functions</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Creating.2C_Joining.2C_and_Identifying_Threads">Creating, Joining, and Identifying Threads</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Controlling_Thread_Priorities">Controlling Thread Priorities</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Controlling_Per-Thread_Private_Data">Controlling Per-Thread Private Data</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Interrupting_and_Yielding">Interrupting and Yielding</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Setting_Global_Thread_Concurrency">Setting Global Thread Concurrency</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Threads#Getting_a_Thread.27s_Scope">Getting a Thread's Scope</a></li>
          </ol>
        </li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Process Initialization</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Initialization#Identity_and_Versioning">Identity and Versioning</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Initialization#Name_and_Version_Constants">Name and Version Constants</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Initialization#Initialization_and_Cleanup">Initialization and Cleanup</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Initialization#Module_Initialization">Module Initialization</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Locks</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Locks#Lock_Type">Lock Type</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Locks#Lock_Functions">Lock Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Condition Variables</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Condition_Variables#Condition_Variable_Type">Condition Variable Type</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Condition_Variables#Condition_Variable_Functions">Condition Variable Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Monitors</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Monitors#Monitor_Type">Monitor Type</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Monitors#Monitor_Functions">Monitor Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Cached Monitors</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Cached_Monitors#Cached_Monitor_Functions">Cached Monitor Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>I/O Types</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#Directory_Type">Directory Type</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#File_Descriptor_Types">File Descriptor Types</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#File_Info_Types">File Info Types</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#Network_Address_Types">Network Address Types</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#Types_Used_with_Socket_Options_Functions">Types Used with Socket Options Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#Type_Used_with_Memory-Mapped_I.2FO">Type Used with Memory-Mapped I/O</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Types#Offset_Interpretation_for_Seek_Functions">Offset Interpretation for Seek Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>I/O Functions</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Functions_that_Operate_on_Pathnames">Functions that Operate on Pathnames</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Functions_that_Act_on_File_Descriptors">Functions that Act on File Descriptors</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Directory_I.2FO_Functions">Directory I/O Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Socket_Manipolation_Functions">Socket Manipolation Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Converting_Between_Host_and_Network_Addresses">Converting Between Host and Network Addresses</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Memory-Mapped_I.2FO_Functions">Memory-Mapped I/O Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Anonymous_Pipe_Function">Anonymous Pipe Function</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Polling_Functions">Polling Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Pollable_Events">Pollable Events</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/I_O_Functions#Manipulating_Layers">Manipulating Layers</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Network Addresses</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Network_Addresses#Network_Address_Types_and_Constants">Network Address Types and Constants</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Network_Addresses#Network_Address_Functions">Network Address Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Atomic Operations</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_AtomicIncrement">PR_AtomicIncrement</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_AtomicDecrement">PR_AtomicDecrement</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_AtomicSet">PR_AtomicSet</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Interval Timing</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Interval_Timing#Interval_Time_Type_and_Constants">Interval Time Type and Constants</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Interval_Timing#Interval_Functions">Interval Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Date and Time</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Date_and_Time#Types_and_Constants">Types and Constants</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Date_and_Time#Time_Parameter_Callback_Functions">Time Parameter Callback Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Date_and_Time#Functions">Functions</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Memory Management Operations</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Memory_Management_Operations#Memory_Allocation_Functions">Memory Allocation Functions</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Memory_Management_Operations#Memory_Allocation_Macros">Memory Allocation Macros</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>String Operations</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PL_strlen">PL_strlen</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PL_strcpy">PL_strcpy</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PL_strdup">PL_strdup</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PL_strfree">PL_strfree</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Floating Point Number to String Conversion</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_strtod">PR_strtod</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_dtoa">PR_dtoa</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_cnvtf">PR_cnvtf</a></li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Linked Lists</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Linked_Lists#Linked_List_Types">Linked List Types</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRCList">PRCList</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Linked_Lists#Linked_List_Macros">Linked List Macros</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_INIT_CLIST">PR_INIT_CLIST</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_INIT_STATIC_CLIST">PR_INIT_STATIC_CLIST</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_APPEND_LINK">PR_APPEND_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_INSERT_LINK">PR_INSERT_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_NEXT_LINK">PR_NEXT_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_PREV_LINK">PR_PREV_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_REMOVE_LINK">PR_REMOVE_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_REMOVE_AND_INIT_LINK">PR_REMOVE_AND_INIT_LINK</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_INSERT_BEFORE">PR_INSERT_BEFORE</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_INSERT_AFTER">PR_INSERT_AFTER</a></li>
          </ol>
        </li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Dynamic Library Linking</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Library_Linking_Types">Library Linking Types</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRLibrary">PRLibrary</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRStaticLinkTable">PRStaticLinkTable</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Library_Linking_Functions">Library Linking Functions</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_SetLibraryPath">PR_SetLibraryPath</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_GetLibraryPath">PR_GetLibraryPath</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_GetLibraryName">PR_GetLibraryName</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_FreeLibraryName">PR_FreeLibraryName</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_LoadLibrary">PR_LoadLibrary</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_UnloadLibrary">PR_UnloadLibrary</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_FindSymbol">PR_FindSymbol</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_FindSymbolAndLibrary">PR_FindSymbolAndLibrary</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Finding_Symbols_Defined_in_the_Main_Executable_Program">Finding Symbols Defined in the Main Executable Program</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Platform_Notes">Platform Notes</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Dynamic_Library_Search_Path">Dynamic Library Search Path</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Dynamic_Library_Linking#Exporting_Symbols_from_the_Main_Executable_Program">Exporting Symbols from the Main Executable Program</a></li>
          </ol>
        </li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Process Management and Interprocess Communication</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Management_and_Interprocess_Communication#Process_Management_Types_and_Constants">Process Management Types and Constants</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRProcess">PRProcess</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRProcessAttr">PRProcessAttr</a></li>
          </ol>
        </li>
        <li><a href="/ja/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Management_and_Interprocess_Communication#Process_Management_Functions">Process Management Functions</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Management_and_Interprocess_Communication#Setting_the_Attributes_of_a_New_Process">Setting the Attributes of a New Process</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Process_Management_and_Interprocess_Communication#Creating_and_Managing_Processes">Creating and Managing Processes</a></li>
          </ol>
        </li>
      </ol>
    </details>
  </li>
  <li class="toggle">
    <details>
      <summary>Logging</summary>
      <ol>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Logging#Conditional_Compilation_and_Execution">Conditional Compilation and Execution</a></li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Logging#Log_Types_and_Variables">Log Types and Variables</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRLogModoleInfo">PRLogModoleInfo</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PRLogModoleLevel">PRLogModoleLevel</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_LOG_MODULES">NSPR_LOG_MODULES</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_LOG_FILE">NSPR_LOG_FILE</a></li>
          </ol>
        </li>
        <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Logging#Logging_Functions_and_Macros">Logging Functions and Macros</a>
          <ol>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_NewLogModole">PR_NewLogModole</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_SetLogFile">PR_SetLogFile</a></li>
            <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_SetLogBuffering">PR_SetLogBuffering</a>/li&gt;
              </li><li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_LogPrint">PR_LogPrint</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_LogFlush">PR_LogFlush</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_LOG_TEST">PR_LOG_TEST</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_LOG">PR_LOG</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_Assert_">PR_Assert</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_ASSERT">PR_ASSERT</a></li>
              <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/PR_NOT_REACHED">PR_NOT_REACHED</a></li>
            </ol>
          </li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Logging#Use_Example">Use Example</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Named Shared Memory</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Named_Shared_Memory#Shared_Memory_Protocol">Shared Memory Protocol</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Named_Shared_Memory#Named_Shared_Memory_Functions">Named Shared Memory Functions</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Anonymous Shared Memory</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Anonymous_Shared_Memory#Anonymous_Memory_Protocol">Anonymous Memory Protocol</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Anonymous_Shared_Memory#Anonymous_Shared_Memory_Functions">Anonymous Shared Memory Functions</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>IPC Semaphores</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/IPC_Semaphores#IPC_Semaphore_Functions">IPC Semaphore Functions</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Thread Pools</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Thread_Pools#Thread_Pool_Types">Thread Pool Types</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Thread_Pools#Thread_Pool_Functions">Thread Pool Functions</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Random Number Generator</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Random_Number_Generator#Random_Number_Generator_Function">Random Number Generator Function</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Hash Tables</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Hash_Tables#Hash_Tables_and_Type_Constants">Hash Tables and Type Constants</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/Hash_Tables#Hash_Table_Functions">Hash Table Functions</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>NSPR Error Handling</summary>
        <ol>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Error_Handling#Error_Type">Error Type</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Error_Handling#Error_Functions">Error Functions</a></li>
          <li><a href="/ja/docs/Mozilla/Projects/NSPR/Reference/NSPR_Error_Handling#Error_Codes">Error Codes</a></li>
        </ol>
      </details>
    </li>
    <li class="toggle">
      <details>
        <summary>Contribute</summary>
        <ol>
          <li><a href="/ja/docs/MDN/Doc_status/NSPR"></a></li>
          <li><a href="/ja/docs/MDN">The MDN Project</a></li>
        </ol>
      </details>
    </li>
  </ol>
</section>

<p>Netscape Portable Runtime (NSPR) APIはスレッド、スレッド同期、I/O、内部タイマー、原子的な操作、そしてその他のプラットフォームに依存しない方法で低レイヤーなサービス等のシステムの機能を使ったアプリケーションに準拠しています。このチャプターではNSPRプログラミングのコンセプトの重要な部分をサンプルコードを使って説明します。</p>

<p>現在のNSPRの実装では、単一のソースコードのみで Macintosh (PPC), Win32 (NT 3.51, NT 4.0, WIN'95), その他２０以上のバージョンのUNIX上でコンパイルすることができます。</p>

<p>NSPRは既存のコードを移植するためのプラットフォームを提供しません。 ソフトウェアプロジェクトの初めから使用しなければなりません。</p>

<h2 id="NSPR_Naming_Conventions" name="NSPR_Naming_Conventions">NSPRの命名規則</h2>

<p>Naming of NSPR types, functions, and macros follows the following conventions:</p>

<ul>
 <li>Types exported by NSPR begin with <code>PR</code> and are followed by intercap-style declarations, like this: <code>PRInt</code>, <code>PRFileDesc</code></li>
 <li>Function definitions begin with <code>PR_</code> and are followed by intercap-style declarations, like this: <code>PR_Read</code>, <code>PR_JoinThread</code></li>
 <li>Preprocessor macros begin with the letters <code>PR</code> and are followed by all uppercase characters separated with the underscore character (<code>_</code>), like this: <code>PR_BYTES_PER_SHORT</code>, <code>PR_EXTERN</code></li>
</ul>

<h2 id="NSPR_Threads" name="NSPR_Threads">NSPRのスレッド</h2>

<p>NSPR provides an execution environment that promotes the use of lightweight threads. Each thread is an execution entity that is scheduled independently from other threads in the same process. A thread has a limited number of resources that it truly owns. These resources include the thread stack and the CPU register set (including PC).</p>

<p>To an NSPR client, a thread is represented by a pointer to an opaque structure of type <code><a href="PRThread">PRThread</a></code>. A thread is created by an explicit client request and remains a valid, independent execution entity until it returns from its root function or the process abnormally terminates. (<code>PRThread</code> and functions for creating and manipulating threads are described in detail in <a href="Threads">Threads</a>.)</p>

<p>NSPR threads are lightweight in the sense that they are cheaper than full-blown processes, but they are not free. They achieve the cost reduction by relying on their containing process to manage most of the resources that they access. This, and the fact that threads share an address space with other threads in the same process, makes it important to remember that<em>threads are not processes</em> .</p>

<p>NSPR threads are scheduled in two separate domains:</p>

<ul>
 <li><strong>Local threads</strong> are scheduled within a process only and are handled entirely by NSPR, either by completely emulating threads on each host operating system (OS) that doesn't support threads, or by using the threading facilities of each host OS that does support threads to emulate a relatively large number of local threads by using a relatively small number of native threads.</li>
</ul>

<ul>
 <li><strong>Global threads</strong> are scheduled by the host OS--not by NSPR--either within a process or across processes on the entire host. Global threads correspond to native threads on the host OS.</li>
</ul>

<p>NSPR threads can also be either user threads or system threads. NSPR provides a function, <code><a href="PR_Cleanup">PR_Cleanup</a></code>, that synchronizes process termination. <code>PR_Cleanup</code> waits for the last user thread to exit before returning, whereas it ignores system threads when determining when a process should exit. This arrangement implies that a system thread should not have volatile data that needs to be safely stored away.</p>

<p>Priorities for NSPR threads are based loosely on hints provided by the client and sometimes constrained by the underlying operating system. Therefore, priorities are not rigidly defined. For more information, see <a href="#Thread_Scheduling">Thread Scheduling</a>.</p>

<p>In general, it's preferable to create local user threads with normal priority and let NSPR take care of the details as appropriate for each host OS. It's usually not necessary to create a global thread explicitly unless you are planning to port your code only to platforms that provide threading services with which you are familiar or unless the thread will be executing code that might directly call blocking OS functions.</p>

<p>Threads can also have "per-thread-data" attached to them. Each thread has a built-in per-thread error number and error string that are updated when NSPR operations fail. It's also possible for NSPR clients to define their own per-thread-data. For details, see <a href="Threads#Controlling_Per-Thread_Private_Data">Controlling Per-Thread Private Data</a>.</p>

<h3 id="Thread_Scheduling" name="Thread_Scheduling">スレッドスケジューリング</h3>

<p>NSPR threads are scheduled by priority and can be preempted or interrupted. The sections that follow briefly introduce the NSPR approach to these three aspects of thread scheduling.</p>

<ul>
 <li><a href="#Setting_Thread_Priorities">Setting Thread Priorities</a></li>
 <li><a href="#Preempting_Threads">Preempting Threads</a></li>
 <li><a href="#Interrupting_Threads">Interrupting Threads</a></li>
</ul>

<p>For reference information on the NSPR API used for thread scheduling, see <a href="Threads">Threads</a>.</p>

<h4 id="Setting_Thread_Priorities" name="Setting_Thread_Priorities">Setting Thread Priorities</h4>

<p>The host operating systems supported by NSPR differ widely in the mechanisms they use to support thread priorities. In general, an NSPR thread of higher priority has a statistically better chance of running relative to threads of lower priority. However, because of the multiple strategies to provide execution vehicles for threads on various host platforms, priorities are not a clearly defined abstraction in NSPR. At best they are intended to specify a preference with respect to the amount of CPU time that a higher-priority thread might expect relative to a lower-priority thread. This preference is still subject to resource availability, and must not be used in place of proper synchronization. For more information on thread synchronization, see <a href="#NSPR_Thread_Synchronization">NSPR Thread Synchronization</a>.</p>

<p>The issue is further muddied by inconsistent offerings from OS vendors regarding the priority of their kernel-supported threads. NSPR assumes that the priorities of global threads are not manageable, but that the host OS will perform some sort of fair scheduling. It's usually preferable to create local user threads with normal priority and let NSPR and the host take care of the details.</p>

<p>In some NSPR configurations, there may be an arbitrary (and perhaps large) number of local threads being supported by a more limited number of <strong>virtual processors</strong> (an internal application of global threads). In such situations, each virtual processor will have some number of local threads associated with it, though exactly which local threads and how many may vary over time. NSPR guarantees that for each virtual processor the highest-priority, schedulable local thread is the one executing. This thread implementation strategy is referred to as the <strong>M x N model. </strong></p>

<h4 id="Preempting_Threads" name="Preempting_Threads">Preempting Threads</h4>

<p>Preemption is the act of taking control away from a ready thread at an arbitrary point and giving control to another appropriate thread. It might be viewed as taking the executing thread and adding it to the end of the ready queue for its appropriate priority, then simply running the scheduling algorithm to find the most appropriate thread. The chosen thread may be of higher priority, of the same priority, or even the same thread. It will not be a thread of lower priority.</p>

<p>Some operating systems cannot be made preemptable (for example, Mac OS and Win 16). This puts them at some risk in supporting arbitrary code, even if the code is interpreted (Java). Other systems are not thread-aware, and their runtime libraries not thread-safe (most versions of Unix). These systems can support local level thread abstractions that can be made preemptable, but run the risk of library corruption (<code>libc</code>). Still other operating systems have a native notion of threads, and their libraries are thread-aware and support locking. However, if local threads are also present, and they are preemptable, they are subject to deadlock. At this time, the only safe solutions are to turn off preemption (a runtime decision) or to preempt global threads only.</p>

<h4 id="Interrupting_Threads" name="Interrupting_Threads">Interrupting Threads</h4>

<p>NSPR threads are interruptable, with some constraints and inconsistencies.</p>

<p>To interrupt a thread, the caller of <code><a href="PR_Interrupt">PR_Interrupt</a></code> must have the NSPR reference to the target thread (<code><a href="PRThread">PRThread</a></code>*). When the target is interrupted, it is rescheduled from the point at which it was blocked, with a status error indicating that it was interrupted. NSPR recognizes only two areas where a thread may be interrupted: waiting on a condition variable and waiting on I/O. In the latter case, interruption does cancel the I/O operation. In neither case does being interrupted imply the demise of the thread.</p>

<h2 id="NSPR_Thread_Synchronization" name="NSPR_Thread_Synchronization">NSPRのスレッドの同期</h2>

<p>Thread synchronization has two aspects: locking and notification. Locking prevents access to some resource, such as a piece of shared data: that is, it enforces mutual exclusion. Notification involves passing synchronization information among cooperating threads.</p>

<p>In NSPR, a <strong>mutual exclusion lock</strong> (or <strong>mutex</strong>) of type <code><a href="PRLock">PRLock</a></code> controls locking, and associated <strong>condition variables</strong> of type <code><a href="PRCondVar">PRCondVar</a></code> communicate changes in state among threads. When a programmer associates a mutex with an arbitrary collection of data, the mutex provides a protective <strong>monitor</strong> around the data.</p>

<h3 id="Locks_and_Monitors" name="Locks_and_Monitors">Locks and Monitors</h3>

<p>In general, a monitor is a conceptual entity composed of a mutex, one or more condition variables, and the monitored data. Monitors in this generic sense should not be confused with the monitor type used in Java programming. In addition to <code><a href="PRLock">PRLock</a></code>, NSPR provides another mutex type, <code><a href="PRMonitor">PRMonitor</a></code>, which is reentrant and can have only one associated condition variable. <code>PRMonitor</code> is intended for use with Java and reflects the Java approach to thread synchronization.</p>

<p>To access the data in the monitor, the thread performing the access must hold the mutex, also described as being "in the monitor." Mutual exclusion guarantees that only one thread can be in the monitor at a time and that no thread may observe or modify the monitored data without being in the monitor.</p>

<p>Monitoring is about protecting data, not code. A <strong>monitored invariant</strong> is a Boolean expression over the monitored data. The expression may be false only when a thread is in the monitor (holding the monitor's mutex). This requirement implies that when a thread first enters the monitor, an evaluation of the invariant expression must yield a <code>true</code>. The thread must also reinstate the monitored invariant before exiting the monitor. Therefore, evaluation of the expression must also yield a true at that point in execution.</p>

<p>A trivial example might be as follows. Suppose an object has three values, <var>v1</var>, <var>v2</var>, and <var>sum</var>. The invariant is that the third value is the sum of the other two. Expressed mathematically, the invariant is <code>sum = v1 + v2</code>. Any modification of <var>v1</var> or <var>v2</var> requires modification of <var>sum</var>. Since that is a complex operation, it must be monitored. Furthermore, any type of access to <var>sum</var> must also be monitored to ensure that neither <var>v1</var> nor <var>v2</var> are in flux.</p>

<div class="note"><strong>Note</strong>: Evaluation of the invariant expression is a conceptual requirement and is rarely done in practice. It is valuable to formally define the expression during design, write it down, and adhere to it. It is also useful to implement the expression during development and test it where appropriate. The thread makes an absolute assertion of the expression's evaluation both on entering and on exiting the monitor.</div>

<p>Acquiring a lock is a synchronous operation. Once the lock primitive is called, the thread returns only when it has acquired the lock. Should another thread (or the same thread) already have the lock held, the calling thread blocks, waiting for the situation to improve. That blocked state is not interruptible, nor is it timed.</p>

<h3 id="Condition_Variables" name="Condition_Variables">Condition Variables</h3>

<p>Condition variables facilitate communication between threads. The communication available is a semantic-free notification whose context must be supplied by the programmer. Conditions are closely associated with a single monitor.</p>

<p>The association between a condition and a monitor is established when a condition variable is created, and the association persists for the life of the condition variable. In addition, a static association exists between the condition and some data within the monitor. This data is what will be manipulated by the program under the protection of the monitor. A thread may wait on notification of a condition that signals changes in the state of the associated data. Other threads may notify the condition when changes occur.</p>

<p>Condition variables are always monitored. The relevant operations on conditions are always performed from within the monitor. They are used to communicate changes in the state of the monitored data (though still preserving the monitored invariant). Condition variables allow one or more threads to wait for a predetermined condition to exist, and they allow another thread to notify them when the condition occurs. Condition variables themselves do not carry the semantics of the state change, but simply provide a mechanism for indicating that something has changed. It is the programmer's responsibility to associate a condition with the state of the data.</p>

<p>A thread may be designed to wait for a particular situation to exist in some monitored data. Since the nature of the situation is not an attribute of the condition, the program must test that itself. Since this testing involves the monitored data, it must be done from within the monitor. The wait operation atomically exits the monitor and blocks the calling thread in a waiting condition state. When the thread is resumed after the wait, it will have reentered the monitor, making operations on the data safe.</p>

<p>There is a subtle interaction between the thread(s) waiting on a condition and those notifying it. The notification must take place within a monitor--the same monitor that protects the data being manipulated by the notifier. In pseudocode, the sequence looks like this:</p>

<pre class="eval">enter(monitor);
... manipulate the monitored data
notify(condition);
exit(monitor);
</pre>

<p>Notifications to a condition do not accumulate. Nor is it required that any thread be waiting on a condition when the notification occurs. The design of the code that waits on a condition must take these facts into account. Therefore, the pseudocode for the waiting thread might look like this:</p>

<pre class="eval">enter(monitor)
while (!expression) wait(condition);
... manipulate monitored data
exit(monitor);
</pre>

<p>The need to evaluate the Boolean expression again after rescheduling from a wait may appear unnecessary, but it is vital to the correct execution of the program. The notification promotes a thread waiting on a condition to a ready state. When that thread actually gets scheduled is determined by the thread scheduler and cannot be predicted. If multiple threads are actually processing the notifications, one or more of them could be scheduled ahead of the one explicitly promoted by the notification. One such thread could enter the monitor and perform the work indicated by the notification, and exit. In this case the thread would resume from the wait only to find that there's nothing to do.</p>

<p>For example, suppose the defined rule of a function is that it should wait until there is an object available and that it should return a reference to that object. Writing the code as follows could potentially return a null reference, violating the invariant of the function:</p>

<pre class="eval">void *dequeue()
{
   void *db;
   enter(monitor);
   if ((db = delink()) == null)
   {
      wait(condition);
      db = delink();
   }
   exit(monitor);
   return db;
}
</pre>

<p>The same function would be more appropriately written as follows:</p>

<pre class="eval">void *dequeue()
{
   void *db;
   enter(monitor);
   while ((db = delink()) == null)
      wait(condition);
   exit(monitor);
   return db;
}
</pre>

<div class="note"><strong>Caution</strong>: The semantics of <code><a href="PR_WaitCondVar">PR_WaitCondVar</a></code> assume that the monitor is about to be exited. This assumption implies that the monitored invariant must be reinstated before calling <code>PR_WaitCondVar</code>. Failure to do this will cause subtle but painful bugs.</div>

<p>To modify monitored data safely, a thread must be in the monitor. Since no other thread may modify or (in most cases) even observe the protected data from outside the monitor, the thread can safely make any modifications needed. When the changes have been completed, the thread notifies the condition associated with the data and exits the monitor using <code><a href="PR_NotifyCondVar">PR_NotifyCondVar</a></code>. Logically, each such notification promotes one thread that was waiting on the condition to a ready state. An alternate form of notification (<code><a href="PR_NotifyAllCondVar">PR_NotifyAllCondVar</a></code>) promotes all threads waiting on a condition to the ready state. If no threads were waiting, the notification is a no-op.</p>

<p>Waiting on a condition variable is an interruptible operation. Another thread could target the waiting thread and issue a <code><a href="PR_Interrupt">PR_Interrupt</a></code>, causing a waiting thread to resume. In such cases the return from the wait operation indicates a failure and definitively indicates that the cause of the failure is an interrupt.</p>

<p>A call to <code><a href="PR_WaitCondVar">PR_WaitCondVar</a></code> may also resume because the interval specified on the wait call has expired. However, this fact cannot be unambiguously delivered, so no attempt is made to do so. If the logic of a program allows for timing of waits on conditions, then the clock must be treated as part of the monitored data and the amount of time elapsed re-asserted when the call returns. Philosophically, timeouts should be treated as explicit notifications, and therefore require the testing of the monitored data upon resumption.</p>

<h2 id="NSPR_Sample_Code" name="NSPR_Sample_Code">NSPRのサンプルコード</h2>

<p>The documents linked here present two sample programs, including detailed annotations: <code><a href="/I%2f%2fO_Layering_Sample">layer.html</a></code> and <code><a href="/Thread_Synchronization_Sample">switch.html</a></code>. In addition to these annotated HTML versions, the same samples are available in pure source form.</p>