#include <rtthread.h>

#define TEST_ITERATIONS      100  // 测试迭代次数
#define THREAD_PRIORITY      25
#define THREAD_STACK_SIZE    4096
#define THREAD_TIMESLICE     100


static struct rt_thread thread[TEST_ITERATIONS];
static rt_uint8_t thread_stack[TEST_ITERATIONS][THREAD_STACK_SIZE];


/* 线程入口函数 */
static void thread_entry(void *parameter)
{
    rt_mutex_t mutex = (rt_mutex_t)parameter;
    
    /* 第一次获取互斥量 */
    rt_kprintf("thread try to take mutex first time\n");
    rt_mutex_take(mutex, RT_WAITING_FOREVER);
    rt_kprintf("thread take mutex first time success\n");
     
    /* 第二次递归获取互斥量 */
    rt_kprintf("thread try to take mutex second time\n");
    rt_mutex_take(mutex, RT_WAITING_FOREVER);
    rt_kprintf("thread take mutex second time success\n");
    
    /* 故意不释放互斥量 */
    rt_kprintf("thread exit without release mutex\n");
    
    while(1) {} // 保持线程运行直到被分离
}

int mutex_recursive_test(void)
{
    int success_count = 0;
    int fail_count = 0;
    
    rt_kprintf("\nStarting mutex recursive stress test (%d iterations)...\n", TEST_ITERATIONS);
    
    for(int i = 0; i < TEST_ITERATIONS; i++) {
        rt_kprintf("\n=== Iteration %d ===\n", i+1);
        
        /* 创建互斥量 */
        rt_mutex_t mutex = rt_mutex_create("test_mutex", RT_IPC_FLAG_PRIO);
        if (mutex == RT_NULL) {
            rt_kprintf("[ERROR] create mutex failed at iteration %d\n", i+1);
            fail_count++;
            continue;
        }

        
        rt_kprintf("Init thread\n");

        /* 初始化线程 */
        rt_thread_init(&thread[i],
                     "test_thread",
                     thread_entry,
                     (void *)mutex,
                     thread_stack[i],
                     sizeof(thread_stack[i]),
                     THREAD_PRIORITY,
                     THREAD_TIMESLICE);
        
        /* 启动线程 */
        rt_thread_startup(&thread[i]);
   
        /* 分离线程 */
        rt_kprintf("main thread detach thread\n");
        rt_thread_detach(&thread[i]);
        
        /* 尝试获取互斥量 */
        rt_kprintf("main thread try to take mutex after detach\n");
        if (rt_mutex_take(mutex, 100) == RT_EOK) {
            rt_kprintf("main thread take mutex success after detach\n");
            rt_mutex_release(mutex);
            success_count++;
        } else {
            rt_kprintf("[BUG] main thread still cannot take mutex!\n");
            fail_count++;
        }
        
        /* 删除互斥量 */
        rt_mutex_delete(mutex);
        
       
    }
    
    /* 输出统计结果 */
    rt_kprintf("\nTest completed:\n");
    rt_kprintf("  Success: %d\n", success_count);
    rt_kprintf("  Failed:  %d\n", fail_count);
    rt_kprintf("  Success rate: %.1f%%\n", (float)success_count/TEST_ITERATIONS*100);
    
    return 0;
}

/* 导出到 msh 命令列表 */
MSH_CMD_EXPORT(mutex_recursive_test, mutex recursive stress test);

t ：线程A获取mutex

t+1 ：线程B尝试关闭分离线程A，释放其持有的mutex。但问题是，调用rt_thread_detach - > _thread_detach ->rt_thread_close 只是将线程A的线程控制块移除调度队列并设置其状态为关闭，然而线程A还可以继续在核心上运行,直到其所在核心触发调度才会完全终止

t+2：线程A再次获取mutex

t+3 : 线程B尝试获取mutex，由于被A占用故失败