Class: Pindo::TaskSystem::ResourceLockManager

Inherits:
Object
  • Object
show all
Defined in:
lib/pindo/module/task/core/resource_lock_manager.rb

Overview

资源锁管理器 v3.0 - 支持基于上下文的资源锁定

功能：

  1. 支持基于目录的资源（相同目录互斥，不同目录可并行）

  2. 支持全局互斥资源（永远互斥）

  3. 支持全局共享资源（永不冲突）

  4. 原子性获取 - 要么全部获取，要么全部失败

  5. 线程安全 - 使用 Mutex 保护

  6. 支持阻塞式获取（带超时）

  7. 支持部分释放资源

资源规格格式：

{ type: :xcode, directory: "/path/to/project" }
{ type: :keychain }
{ type: :network }

Defined Under Namespace

Classes: ResourceLockTimeout

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ResourceLockManager 



25
26
27
28
29
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 25

def initialize
  @mutex = Mutex.new
  @locked_resources = []  # [{ instance: ResourceInstance, task_id: String }]
  @registry = TaskResources::ResourceRegistry.new
end

Instance Method Details

#acquire_blocking(resource_specs, task_id, timeout: 30) ⇒ Boolean

阻塞式获取资源锁（带超时）



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 57

def acquire_blocking(resource_specs, task_id, timeout: 30)
  return true if resource_specs.nil? || resource_specs.empty?

  deadline = Time.now + timeout

  loop do
    return true if try_acquire(resource_specs, task_id)

    if Time.now >= deadline
      return false  # 超时
    end

    sleep(0.1)  # 短暂等待后重试
  end
end

#available?(resource_specs) ⇒ Boolean

检查资源是否可用



101
102
103
104
105
106
107
108
109
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 101

def available?(resource_specs)
  return true if resource_specs.nil? || resource_specs.empty?

  instances = parse_resource_specs(resource_specs)

  @mutex.synchronize do
    !has_conflicts?(instances)
  end
end

#lock_status ⇒ Hash

获取资源锁定状态（用于调试和监控）



113
114
115
116
117
118
119
120
121
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 113

def lock_status
  @mutex.synchronize do
    {
      total_locks: @locked_resources.size,
      locks_by_task: group_locks_by_task,
      locks_by_resource: group_locks_by_resource
    }
  end
end

#locked_resources(task_id) ⇒ Array<ResourceInstance>

获取任务占用的资源列表



126
127
128
129
130
131
132
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 126

def locked_resources(task_id)
  @mutex.synchronize do
    @locked_resources
      .select { |lock| lock[:task_id] == task_id }
      .map { |lock| lock[:instance] }
  end
end

#release(task_id) ⇒ Object

释放任务占用的所有资源



75
76
77
78
79
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 75

def release(task_id)
  @mutex.synchronize do
    @locked_resources.delete_if { |lock| lock[:task_id] == task_id }
  end
end

#release_partial(resource_specs, task_id) ⇒ Object

释放任务占用的部分资源



84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 84

def release_partial(resource_specs, task_id)
  return if resource_specs.nil? || resource_specs.empty?

  instances = parse_resource_specs(resource_specs)

  @mutex.synchronize do
    instances.each do |instance|
      @locked_resources.delete_if do |lock|
        lock[:task_id] == task_id && lock[:instance].matches?(instance)
      end
    end
  end
end

#try_acquire(resource_specs, task_id) ⇒ Boolean

尝试获取资源锁（非阻塞）



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/pindo/module/task/core/resource_lock_manager.rb', line 35

def try_acquire(resource_specs, task_id)
  return true if resource_specs.nil? || resource_specs.empty?

  instances = parse_resource_specs(resource_specs)

  @mutex.synchronize do
    return false if has_conflicts?(instances)

    # 锁定所有资源
    instances.each do |instance|
      @locked_resources << { instance: instance, task_id: task_id }
    end

    true
  end
end