Provided by: aolserver4-dev_4.5.1-16_amd64 bug


       ns_thread - commands


       ns_thread begin script

       ns_thread begindetached script

       ns_thread get

       ns_thread getid

       ns_thread wait tid

       ns_thread yield



       ns_thread begin:
              begins a new thread which evaluates the specified script and then exits. It returns
              a thread ID that must eventually be passed to  ns_thread  wait.  (Failing  to  call
              ns_thread wait will eventually result in no new threads being created.)

       ns_thread begindetached:
              begins a detached thread that doesn't have to be (and can't be) waited for.

       ns_thread get:
              gets  the  thread  ID  of the current thread. The result is a thread ID that can be
              passed to ns_thread wait and may look something like "tid532".

       ns_thread getid:
              gets the thread integer number for the  current  thread.  The  result  is  a  small
              integer  used  for  identifying  threads  is  a  human-readable way, such as "1" or
              "1120", for example.

       ns_thread wait:
              waits for the specified thread to exit. The tid argument is a thread ID returned by
              ns_thread begin or ns_thread get.

       ns_thread yield:
              causes the current thread to yield.


       This  example  is similar to the example under the ns_sockselect function of connecting to
       the 10 servers and waiting to service them with the ns_sockselect command. In  this  case,
       though, each connection gets it's own thread.

       #  This  is  the  procedure  which  is  evaluated  for  each thread and # handles a single
       connection to host number $i

       proc getpage {i} {
           global pages
           # new thread will start here - first connect to host
           set host [format "" $i]
           set fds [ns_sockopen $host 80
           set r [lindex $fds 0]
           set w [lindex $fds 1]
           # next, send request            0r"
           puts $w "GET /index.htm HTTP/1.0
           flush $w
           # then read page
           set pages($i) [read $r]
           # and close sockets
           close $w
           close $r
           # thread goes away here and other threads waiting
           # on ns_thread wait will wakeup }

       # Here's the loop which creates the threads which run getpage.  for {set i  1}  {$i  <  9}
       {incr i} {
           set tids($i) [ns_thread begin "getpage $i"] }

       #  wait for the threads to exit and then process the pages for {set i 1} {$i < 9} {incr i}
           ns_thread wait $tids($i)
           # output page
           ... process the page in $pages($i) put there by other thread ...  }

       Note that the code here is much simpler to follow than the ns_sockselect  example;  that's
       the  benefit of multithreaded programming. However, it uses more resources as threads need
       to be created and initialized. This can be a problem if you plan to create many threads.