SocketSemaphore         package:R.filelocks         R Documentation

_T_h_e _S_o_c_k_e_t_S_e_m_a_p_h_o_r_e _c_l_a_s_s

_D_e_s_c_r_i_p_t_i_o_n:

     Package:  R.filelocks 
      *Class SocketSemaphore*

     'Object'
      '~~|'
      '~~+--''AbstractSemaphore'
      '~~~~~~~|'
      '~~~~~~~+--''SocketSemaphore'

     *Directly known subclasses:*


     public static class *SocketSemaphore*
      extends _AbstractSemaphore_

     A SocketSemaphore is a class for acquiring a semphore from a
     server.

_U_s_a_g_e:

     SocketSemaphore(host="127.0.0.1", port=7777, ...)

_A_r_g_u_m_e_n_t_s:

host, port: The hostname and port number of the server.

     ...: Not used.

_F_i_e_l_d_s _a_n_d _M_e_t_h_o_d_s:

     *Methods:*

         'finalize'    -
         'isAcquired'  -
         'release'     -
         'tryAcquire'  -

     *Methods inherited from AbstractSemaphore*:
      acquire, finalize, release, tryAcquire

     *Methods inherited from Object*:
      $, $<-, [[, [[<-, as.character, attach, attachLocally,
     clearCache, clone, detach, equals, extend, finalize, gc,
     getEnvironment, getFields, getInstantiationTime,
     getStaticInstance, hasField, hashCode, ll, load, objectSize,
     print, save

_A_u_t_h_o_r(_s):

     Henrik Bengtsson (<URL: http://www.braju.com/R/>)

_E_x_a_m_p_l_e_s:

     ## Not run: 
       
     # Run a seperate R process providing a semaphore server
     srv <- SocketSemaphoreServer(port=7777);
     run(srv, verbose=-10);

       
     # Run an R process to wait for a semaphore, do some
     # job that requires atomic transactions, release the
     # semaphore, and so on.

     # Server that controls the semaphore
     host <- "127.0.0.1"

     token <- SocketSemaphore(host, port=7777)
     for (kk in 1:50) {
       if (acquire(token)) {
         cat("Client acquired semaphore.\n")
         Sys.sleep(runif(n=1, max=0.01))
         release(token)
         cat("Client released semaphore.\n")
         Sys.sleep(runif(n=1, max=0.1))
       }
     }

      ## End(Not run)

