怎么理解st_thread库（4）

最新推荐文章于 2024-02-21 13:56:55 发布

ddr77

最新推荐文章于 2024-02-21 13:56:55 发布

阅读量2.5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： st-thead

本文链接：https://blog.youkuaiyun.com/ddr77/article/details/52757515

st-thead 专栏收录该内容

5 篇文章

订阅专栏

本文通过一个简单的示例介绍st_thread库的调用过程，探讨如何初始化jump_buf以及线程间的切换。st_thread_create()函数中初始化jmp_buff，并设定执行函数_main()。当遇到系统阻塞函数时，st库提供st_sleep()等同步函数避免阻塞。st_thread_exit()函数涉及调度，longjmp()的调用与_ST_RESTORE_CONTEXT()相关。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

st_thread的的调用过程是在过于复杂。为了方便理解，我想写了个比较简单的例子

代码如下

// jumptest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>
#include <setjmp.h>

jmp_buf buf;
jmp_buf buf_banana;
jmp_buf buf_apple;


void  banana()
{
	printf("in banana() \n");
	if (setjmp(buf_banana))
	{
		printf("jump banana() \n");
		longjmp(buf, 2);
	}
	else
	{
		printf("first enter banana \n");
		longjmp(buf, 2);
	}
	
	printf("you'll never see this,because i longjmp'd");
}

void  apple()
{
	printf("in apple() \n");
	if (setjmp(buf_apple))
	{
		printf("jump apple() \n");
		longjmp(buf, 3);
	}
	else
	{
		printf("first enter apple \n");
		longjmp(buf, 3);
	}

	printf("you'll never see this,because i longjmp'd");
}


int _tmain(int argc, _TCHAR* argv[])
{
	int _setResult = 0;
	bool  _bAppleIni = false;
	if (_setResult = setjmp(buf))
	{
		Sleep(1000);
		printf("back in main,%d\n", _setResult);
		switch (_setResult)
		{
		case  0:
		{
         break;
		}


		case  2://banana---->apple
		{
					if (false == _bAppleIni)
					{
						_bAppleIni = true;
						apple();
					}
					else
					{
						longjmp(buf_apple, 1);
					}
					break;
		}
		case 3://apple----->banana
		{
				   longjmp(buf_banana, 1);
				   break;;
		}
		default:
			break;
		}
		 
	}
	else{
		printf("first time through ,%d\n", _setResult);
		banana();
	}
	return 0;
}

代码的作用是线程可以在主线程 banana（）函数 apple()函数直接来回切换。为了增加一些可控性，其他函数的切换都必须通过主函数来统一调度，方法是通过longjmp()函数的第二个函数。

运行结果如下

可以看到线程是连续的在主函数 banana()函数 apple()函数直接来回切换的。

猜想st的调用过程原理可能和这个一样，虽然远比这个要复杂的多。那么第一个问题

怎么初始化各个点的jum_buf;

搜索了一下代码。发现在st_thread_create()函数中，有这么一段代码

#ifndef __ia64__
  _ST_INIT_CONTEXT(thread, stack->sp, _st_thread_main);
#else
  _ST_INIT_CONTEXT(thread, stack->sp, stack->bsp, _st_thread_main);
#endif

不是x64架构的先不管，那么走的通常是第一个宏

#ifdef MD_INIT_CONTEXT
#define _ST_INIT_CONTEXT MD_INIT_CONTEXT
#else
#error Unknown OS
#endif

继续往下，这个宏为了兼容多平台，有很多的实现。就拿第一个来

#define MD_INIT_CONTEXT(_thread, _sp, _main) \
  ST_BEGIN_MACRO                             \
  if (MD_SETJMP((_thread)->context))         \
    _main();                                 \
  (_thread)->context[3] = (long) (_sp);      \
  ST_END_MACRO

翻译过来，就是

void md_init_context(_thread,_sp,_main)
{
	if(_setjmp(_thread->context))
	{
		_main()
	}
}

这个函数有两个意思

1）初始设定jmp_buff;

2)设定从第三方跳转过来的执行函数_main()

_main()函数的实现为

void _st_thread_main(void)
{
  _st_thread_t *thread = _ST_CURRENT_THREAD();

  /*
   * Cap the stack by zeroing out the saved return address register
   * value. This allows some debugging/profiling tools to know when
   * to stop unwinding the stack. It's a no-op on most platforms.
   */
  MD_CAP_STACK(&thread);

  /* Run thread main */
  thread->retval = (*thread->start)(thread->arg);

  /* All done, time to go away */
  st_thread_exit(thread->retval);
}

到这里，稍微明白了一点，如果有从其他函数调过来。会执行start()函数体。

从这里可以看出，如果start()函数中，有系统阻塞函数。比如sleep，或者同步原语，那么就会造成整个st系统的阻塞。所以st库提供了st_sleep（），以及和同步相关的一系列的函数。

具体执行过程是在st_thread_exit()函数里。实现为

void st_thread_exit(void *retval)
{
  _st_thread_t *thread = _ST_CURRENT_THREAD();

  thread->retval = retval;
  _st_thread_cleanup(thread);
  _st_active_count--;
  if (thread->term) {
    /* Put thread on the zombie queue */
    thread->state = _ST_ST_ZOMBIE;
    _ST_ADD_ZOMBIEQ(thread);

    /* Notify on our termination condition variable */
    st_cond_signal(thread->term);

    /* Switch context and come back later */
    _ST_SWITCH_CONTEXT(thread);

    /* Continue the cleanup */
    st_cond_destroy(thread->term);
    thread->term = NULL;
  }

#ifdef DEBUG
  _ST_DEL_THREADQ(thread);
#endif

  if (!(thread->flags & _ST_FL_PRIMORDIAL))
    _st_stack_free(thread->stack);

  /* Find another thread to run */
  _ST_SWITCH_CONTEXT(thread);
  /* Not going to land here */
}

这里有个重要的宏_ST_SWITCH_CONTEXT

#define _ST_SWITCH_CONTEXT(_thread)       \
    ST_BEGIN_MACRO                        \
    ST_SWITCH_OUT_CB(_thread);            \
    if (!MD_SETJMP((_thread)->context)) { \
      _st_vp_schedule();                  \
    }                                     \
    ST_DEBUG_ITERATE_THREADS();           \
    ST_SWITCH_IN_CB(_thread);             \
    ST_END_MACRO

那么下一个问题。st库是怎么调度这些函数的呢？

查找longjum()函数的调用，只有一个地方

void _st_vp_schedule(void)
{
  _st_thread_t *thread;

  if (_ST_RUNQ.next != &_ST_RUNQ) {
    /* Pull thread off of the run queue */
    thread = _ST_THREAD_PTR(_ST_RUNQ.next);
    _ST_DEL_RUNQ(thread);
  } else {
    /* If there are no threads to run, switch to the idle thread */
    thread = _st_this_vp.idle_thread;
  }
  ST_ASSERT(thread->state == _ST_ST_RUNNABLE);

  /* Resume the thread */
  thread->state = _ST_ST_RUNNING;
  _ST_RESTORE_CONTEXT(thread);
}

看看_ST_RESTORE_CONTEXT()的实现

#define _ST_RESTORE_CONTEXT(_thread)   \
    ST_BEGIN_MACRO                     \
    _ST_SET_CURRENT_THREAD(_thread);   \
    MD_LONGJMP((_thread)->context, 1); \
    ST_END_MACRO

而_st_vp_schedule()的调用，又在宏_ST_SWITCH_COCNTEX()中。这好像是一个死循环。那么问，第一次longjump，发生在什么地方，只要有第一次调用，这个循环就可以运转起来。这个需要从st_ini()函数中去查找