Update app.py

app.py

@@ -2,60 +2,78 @@ import os
 import threading
 import traceback
 import sys
-import fcntl
 
-# ====================== 核心：原子性文件锁（操作系统级别，绝对单次执行） ======================
-def execute_only_once(func):
-    """装饰器：通过原子性文件锁，确保函数只执行一次（无视Python线程/模块隔离）"""
-    # 锁文件路径（容器内选/tmp，确保可写）
-    LOCK_FILE = "/tmp/photo_show_atomic.lock"
-    # 标记文件：记录是否执行成功
-    MARK_FILE = "/tmp/photo_show_done.mark"
+# ====================== 核心配置：持久化计数文件（放在/app目录，非/tmp） ======================
+# 选择/app目录（代码目录，容器内一般可写，且不会被临时清理）
+COUNT_FILE = "/app/photo_show_count.txt"
+# 最大执行次数：只允许执行1次
+MAX_EXECUTE_TIMES = 1
 
-    def wrapper(*args, **kwargs):
-        # 第一步：先判断是否已执行成功（快速返回，避免重复操作锁文件）
-        if os.path.exists(MARK_FILE):
-            print(f"【跳过】线程{threading.current_thread().ident}：函数已执行成功，直接返回")
-            return
+# ====================== 原子性读写计数（解决多线程/多MainThread的计数竞争） ======================
+def get_and_increment_count():
+    """原子性读取并增加执行计数，返回当前计数"""
+    # 初始化计数文件（若不存在）
+    if not os.path.exists(COUNT_FILE):
+        with open(COUNT_FILE, "w") as f:
+            f.write("0")
+        # 赋予读写权限（防止容器权限问题）
+        os.chmod(COUNT_FILE, 0o644)
 
-        # 第二步：原子性创建锁文件（操作系统级别的原子操作，唯一能保证单次执行）
+    # 原子性操作：用文件锁包裹读写（防止两个MainThread同时读写）
+    with open(COUNT_FILE, "r+") as f:
+        # 加文件锁（Windows用msvcrt，Linux用fcntl，这里兼容Linux容器）
         try:
-            # O_CREAT：创建文件；O_EXCL：如果文件已存在，抛出异常；O_WRONLY：只写
-            fd = os.open(LOCK_FILE, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-            # 写入当前线程/进程信息（可选，用于排查）
-            os.write(fd, f"pid:{os.getpid()}, tid:{threading.current_thread().ident}".encode())
-            os.close(fd)
-        except FileExistsError:
-            # 锁文件已存在，说明已有线程在执行，直接返回
-            print(f"【跳过】线程{threading.current_thread().ident}：已有线程在执行，返回")
-            return
+            import fcntl
+            fcntl.flock(f, fcntl.LOCK_EX)
+        except ImportError:
+            # Windows环境备用（若需要）
+            import msvcrt
+            msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1024)
 
-        # 第三步：执行目标函数（只有拿到锁的线程能走到这里）
-        try:
-            result = func(*args, **kwargs)
-            # 执行成功，创建标记文件
-            with open(MARK_FILE, "w") as f:
-                f.write("done")
-            return result
-        except Exception as e:
-            print(f"【错误】函数执行失败：{e}")
-            # 执行失败，删除锁文件，允许下次执行
-            if os.path.exists(LOCK_FILE):
-                os.remove(LOCK_FILE)
-            raise e
-        finally:
-            # 可选：执行完成后删除锁文件（若需要下次启动重新执行，取消注释）
-            # if os.path.exists(LOCK_FILE):
-            #     os.remove(LOCK_FILE)
-            pass
+        # 读取当前计数
+        current_count = int(f.read().strip())
+        # 移动文件指针到开头，写入新计数
+        f.seek(0)
+        f.write(str(current_count + 1))
+        f.truncate()  # 截断多余内容
+
+        # 释放锁（with块结束后自动释放）
+        return current_count + 1
+
+# ====================== 装饰器：限制执行次数 ======================
+def limit_execute_times(max_times):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            # 获取当前执行次数
+            current_count = get_and_increment_count()
+            print(f"【执行计数】当前是第{current_count}次执行，最大允许{max_times}次")
 
-    return wrapper
+            # 超过次数则返回
+            if current_count > max_times:
+                print(f"【跳过】线程{threading.current_thread().ident}（{threading.current_thread().name}）：已达到最大执行次数，返回")
+                return None
 
-# ====================== 核心功能函数（用原子锁装饰器包裹） ======================
-@execute_only_once
+            # 未超过次数则执行函数
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                print(f"【错误】执行失败：{e}")
+                # 执行失败：回退计数（可选，根据需求）
+                with open(COUNT_FILE, "r+") as f:
+                    import fcntl
+                    fcntl.flock(f, fcntl.LOCK_EX)
+                    f.seek(0)
+                    f.write(str(current_count - 1))
+                    f.truncate()
+                raise e
+        return wrapper
+    return decorator
+
+# ====================== 核心功能函数（限制执行次数为1次） ======================
+@limit_execute_times(MAX_EXECUTE_TIMES)
 def show_photos():
     # ========== 上下文日志（保留，用于排查） ==========
-    print(f"\n【上下文】进程ID：{os.getpid()}，线程ID：{threading.current_thread().ident}")
+    print(f"\n【上下文】进程ID：{os.getpid()}，线程ID：{threading.current_thread().ident}，线程名：{threading.current_thread().name}")
     print(f"【调用栈】：{''.join(traceback.format_stack())}")
     # ========== 原有业务逻辑 ==========
     photos = ["廖荣全.jpg"]
@@ -63,20 +81,19 @@ def show_photos():
     for photo in photos:
         print(f"已显示: {photo}")
 
-# ====================== 关键：用__main__守护 + 强制清理残留锁（可选） ======================
-if __name__ == '__main__':
-    # 可选：容器重启时，若有残留的标记文件，可根据需求删除（比如每次启动都要执行一次）
-    # MARK_FILE = "/tmp/photo_show_done.mark"
-    # LOCK_FILE = "/tmp/photo_show_atomic.lock"
-    # if os.path.exists(MARK_FILE):
-    #     os.remove(MARK_FILE)
-    # if os.path.exists(LOCK_FILE):
-    #     os.remove(LOCK_FILE)
+    # ========== 打印线程信息（根因定位） ==========
+    print("\n【所有线程详情（根因定位）】：")
+    for thread in threading.enumerate():
+        print(f"线程名：{thread.name}，ID：{thread.ident}，守护线程：{thread.daemon}")
 
+# ====================== 主执行逻辑（保留__main__守护） ======================
+if __name__ == '__main__':
     # 只执行一次调用
     show_photos()
 
-    # ========== 可选：打印所有线程信息（定位根因） ==========
-    print("\n【所有线程详情（根因定位）】：")
-    for thread in threading.enumerate():
-        print(f"线程名：{thread.name}，ID：{thread.ident}，守护线程：{thread.daemon}")
+    # 可选：容器启动后，若需要清理计数文件（比如下次启动重新执行），可注释掉以下代码
+    # import atexit
+    # def clean_count_file():
+    #     if os.path.exists(COUNT_FILE):
+    #         os.remove(COUNT_FILE)
+    # atexit.register(clean_count_file)