Module Sync_m
In: sync.rb

Methods

Classes and Modules

Class Sync_m::Err

Constants

RCS_ID = '-$Header: /src/ruby/lib/sync.rb,v 1.4 2001/06/06 14:19:33 keiju Exp $-'
UN = :UN   lock mode
SH = :SH
EX = :EX

Attributes

sync_ex_count  [RW] 
sync_ex_locker  [RW] 
sync_mode  [RW] 
sync_sh_locker  [RW] 
sync_upgrade_waiting  [RW] 
sync_waiting  [RW] 

Public Class methods

[Source]

# File sync.rb, line 90
  def Sync_m.append_features(cl)
    super
    unless cl.instance_of?(Module)
      # do nothing for Modules
      # make aliases and include the proper module.
      define_aliases(cl)
    end
  end

[Source]

# File sync.rb, line 78
  def Sync_m.define_aliases(cl)
    cl.module_eval %q{
      alias locked? sync_locked?
      alias shared? sync_shared?
      alias exclusive? sync_exclusive?
      alias lock sync_lock
      alias unlock sync_unlock
      alias try_lock sync_try_lock
      alias synchronize sync_synchronize
    }
  end

[Source]

# File sync.rb, line 99
  def Sync_m.extend_object(obj)
    super
    obj.sync_extended
  end

[Source]

# File sync.rb, line 254
  def initialize(*args)
    sync_initialize
    super
  end

Public Instance methods

[Source]

# File sync.rb, line 126
  def sync_exclusive?
    sync_mode == EX
  end

[Source]

# File sync.rb, line 104
  def sync_extended
    unless (defined? locked? and
            defined? shared? and
            defined? exclusive? and
            defined? lock and
            defined? unlock and
            defined? try_lock and
            defined? synchronize)
      Sync_m.define_aliases(class<<self;self;end)
    end
    sync_initialize
  end

[Source]

# File sync.rb, line 140
  def sync_lock(m = EX)
    return unlock if m == UN

    until (Thread.critical = true; sync_try_lock_sub(m))
      if sync_sh_locker[Thread.current]
        sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
        sync_sh_locker.delete(Thread.current)
      else
        sync_waiting.push Thread.current
      end
      Thread.stop
    end
    Thread.critical = false
    self
  end

accessing

[Source]

# File sync.rb, line 118
  def sync_locked?
    sync_mode != UN
  end

[Source]

# File sync.rb, line 122
  def sync_shared?
    sync_mode == SH
  end

[Source]

# File sync.rb, line 226
  def sync_synchronize(mode = EX)
    begin
      sync_lock(mode)
      yield
    ensure
      sync_unlock
    end
  end

locking methods.

[Source]

# File sync.rb, line 131
  def sync_try_lock(mode = EX)
    return unlock if sync_mode == UN
    
    Thread.critical = true
    ret = sync_try_lock_sub(sync_mode)
    Thread.critical = false
    ret
  end

[Source]

# File sync.rb, line 156
  def sync_unlock(m = EX)
    Thread.critical = true
    if sync_mode == UN
      Thread.critical = false
      Err::UnknownLocker.Fail(Thread.current)
    end
    
    m = sync_mode if m == EX and sync_mode == SH
    
    runnable = false
    case m
    when UN
      Thread.critical = false
      Err::UnknownLocker.Fail(Thread.current)
      
    when EX
      if sync_ex_locker == Thread.current
        if (self.sync_ex_count = sync_ex_count - 1) == 0
          self.sync_ex_locker = nil
          if sync_sh_locker.include?(Thread.current)
            self.sync_mode = SH
          else
            self.sync_mode = UN
          end
          runnable = true
        end
      else
        Err::UnknownLocker.Fail(Thread.current)
      end
      
    when SH
      if (count = sync_sh_locker[Thread.current]).nil?
        Err::UnknownLocker.Fail(Thread.current)
      else
        if (sync_sh_locker[Thread.current] = count - 1) == 0 
          sync_sh_locker.delete(Thread.current)
          if sync_sh_locker.empty? and sync_ex_count == 0
            self.sync_mode = UN
            runnable = true
          end
        end
      end
    end
    
    if runnable
      if sync_upgrade_waiting.size > 0
        for k, v in sync_upgrade_waiting
          sync_sh_locker[k] = v
        end
        wait = sync_upgrade_waiting
        self.sync_upgrade_waiting = []
        Thread.critical = false
        
        for w, v in wait
          w.run
        end
      else
        wait = sync_waiting
        self.sync_waiting = []
        Thread.critical = false
        for w in wait
          w.run
        end
      end
    end
    
    Thread.critical = false
    self
  end

[Validate]