高性能组件（4）try-catch实现

最新推荐文章于 2021-12-29 13:16:19 发布

amanda39

最新推荐文章于 2021-12-29 13:16:19 发布

阅读量618

点赞数

分类专栏：高性能组件文章标签： c++ linux 服务器

本文链接：https://blog.csdn.net/qq_34130311/article/details/121475514

版权

高性能组件专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文主要讲try catch的实现。
面试微软会遇到。

try/catch/finally：调试，捕获，最终
try_catch用法：
比如：
连接数据库时有可能失败
try{
connect_spq(); //throw 抛出个异常
string.copy(); //函数内部抛出异常
}
catch(){
//捕获异常
}
finally(){
//不管你有没有走，这一步一定会走
}

setjmp/longjmp函数：
1、可以跨越函数的跳跃，可从函数A跳到函数B；
2、调用longjmp函数执行完后，会跳到 setjmp函数处，setjmp函数的返回值就是调用longjmp函数的第二个参数。
3、setjmp和longjmp是没有压栈的。是直接跳转的。
4、这两个函数本身是线程安全的。
代码测试使用longjmp/setjmp：

jmp_buf env;
int count = 0;


void sub_func(int idx) {
	printf("sub_func --> idx:%d\n", idx);
	longjmp(env, idx);
}

int main(int argc, char *argv[]) {

	int idx = 0;

	count = setjmp(env);
	if (count == 0) {
		printf("count:%d\n", count);
		sub_func(++idx);
	} else if (count == 1) {
		printf("count:%d\n", count);
		sub_func(++idx);
	} else if (count == 2) {
		printf("count:%d\n", count);
		sub_func(++idx);
	} else if (count == 3) {
		printf("count:%d\n", count);
		sub_func(++idx);
	} else {
		printf("other count\n");
	}

	return 0;
}

try catch与longjmp/setjmp的关系：
try—>setjmp 设置标签
throw–>longjmp 抛出
catch–>捕获标签
不管什么时候都会执行的 finally
注意：
系统崩溃try catch无用，应该用捕获信号来做，try catch是做业务的。

longjmp/setjmp初步实现try catch：

typedef struct _tagExcepSign {
	jmp_buf _stackinfo; //longjmp的第一个参数， 设置setjmp的第一个参数
	int _exceptype; //longjmp的第二个参数
} tagExcepSign;

#define ExcepType(ExcepSign) ((ExcepSign)._exceptype)

#define Try(ExcepSign) if (((ExcepSign)._exceptype = setjmp((ExcepSign)._stackinfo)) == 0)

#define Catch(ExcepSign, ExcepType)  else if ((ExcepSign)._exceptype == ExcepType)

#define Finally		else 

#define Throw(ExcepSign, ExcepType)	longjmp((ExcepSign)._stackinfo, ExcepType)



void ExceptionTest(int expType) {
	tagExcepSign ex;

	expType = expType < 0 ? -expType : expType;
 
	Try (ex) { //设置标签 setjmp
		if (expType > 0) {
			Throw(ex, expType); //抛出到longjmp, 执行完longjmp后会跳转到setjmp
		} else {
			printf("no exception\n");
		}
	} Catch (ex, 1) { //捕获
		printf("no exception 1\n");
	} Catch (ex, 2) {
		printf("no exception 2\n");
	} Finally {
		printf("other exp\n");
	}
	
}


int main() {
	ExceptionTest(0);
	ExceptionTest(1);
	ExceptionTest(2);
	ExceptionTest(3);
}

实现try catch需要注意的三个问题：
1、try catch的嵌套：只有里层处理完了之后，外层才可处理。
换句话说就是后进先出，这样就是栈的概念，我们可以通过链表来实现这个要求。
单向链表，头插入，取也是从头结点处取。
做成每一个线程，一个调用栈。
2、抛异常时会告诉在哪个文件，行号多少，函数名，
FILE， LINE, func
3、多个线程同时操作时，如何保证线程安全？也就是说多个try catch操作时，如何确保A抛出的异常是A catch来捕获的。
使用pthread_key_t。pthread_key_t是全局key，但是线程中都有空间，名字是一样的，但是内容和位置是不一样的。是每一个线程的私有数据

代码实现：

//pthread_key_t是全局key，但是线程中都有空间，名字是一样的，但是内容和位置是不一样的。是每一个线程的私有数据
#define ntyThreadData		pthread_key_t
#define ntyThreadDataSet(key, value)	pthread_setspecific((key), (value))
#define ntyThreadDataGet(key)		pthread_getspecific((key))
#define ntyThreadDataCreate(key)	pthread_key_create(&(key), NULL)


#define EXCEPTIN_MESSAGE_LENGTH		512

typedef struct _ntyException {
	const char *name;
} ntyException; 

ntyException SQLException = {"SQLException"};
ntyException TimeoutException = {"TimeoutException"};

ntyThreadData ExceptionStack; //保证线程安全

//用链表实现栈，帮助实现try catch特性，节点，try一次就是入栈创建一个几点，throw就是出栈抛出一个节点
typedef struct _ntyExceptionFrame {
	jmp_buf env;

	int line; //存储调到哪一行
	const char *func; //存储是哪个函数
	const char *file; //存储是哪个文件

	ntyException *exception;
	struct _ntyExceptionFrame *prev; //前向指针，保证节点是连接起来的，并且可以找到头节点
	
	char message[EXCEPTIN_MESSAGE_LENGTH+1]; //异常时要输出的文字

} ntyExceptionFrame;


#define ntyExceptionPopStack	\
	ntyThreadDataSet(ExceptionStack, ((ntyExceptionFrame*)ntyThreadDataGet(ExceptionStack))->prev)

#define ReThrow					ntyExceptionThrow(frame.exception, frame.func, frame.file, frame.line, NULL)
#define Throw(e, cause, ...) 	ntyExceptionThrow(&(e), __func__, __FILE__, __LINE__, cause, ##__VA_ARGS__, NULL)


enum {
	ExceptionEntered = 0,
	ExceptionThrown,
	ExceptionHandled,
	ExceptionFinalized
};


#define Try do {							\
			//实际上try就是入栈，创建一个节点
			volatile int Exception_flag;	\
			ntyExceptionFrame frame;		\
			frame.message[0] = 0;			\
			//获取栈的头结点
			frame.prev = (ntyExceptionFrame*)ntyThreadDataGet(ExceptionStack);	\
			//将创建的节点设为头结点，保证后进先出
			ntyThreadDataSet(ExceptionStack, &frame);	\
			Exception_flag = setjmp(frame.env);			\
			if (Exception_flag == ExceptionEntered) {	//关注到此为止即可
			

#define Catch(e) \
				if (Exception_flag == ExceptionEntered) ntyExceptionPopStack; \
			} else if (frame.exception == &(e)) { \
				Exception_flag = ExceptionHandled;


#define Finally \
				if (Exception_flag == ExceptionEntered) ntyExceptionPopStack; \
			} { \
				if (Exception_flag == ExceptionEntered)	\
					Exception_flag = ExceptionFinalized; 

#define EndTry \
				if (Exception_flag == ExceptionEntered) ntyExceptionPopStack; \
			} if (Exception_flag == ExceptionThrown) ReThrow; \
        	} while (0)	


static pthread_once_t once_control = PTHREAD_ONCE_INIT;

static void init_once(void) { 
	ntyThreadDataCreate(ExceptionStack); 
}


void ntyExceptionInit(void) {
	pthread_once(&once_control, init_once);
}

//抛出
void ntyExceptionThrow(ntyException *excep, const char *func, const char *file, int line, const char *cause, ...) {

	va_list ap; //固定用法，其实代表传参的省略号: ...
	ntyExceptionFrame *frame = (ntyExceptionFrame*)ntyThreadDataGet(ExceptionStack); //获取头节点

	if (frame) {

		frame->exception = excep;
		frame->func = func;
		frame->file = file;
		frame->line = line;

		if (cause) {
			va_start(ap, cause); //ap从casue开始
			vsnprintf(frame->message, EXCEPTIN_MESSAGE_LENGTH, cause, ap);
			va_end(ap);
		}

		ntyExceptionPopStack;

		longjmp(frame->env, ExceptionThrown);
		
	} else if (cause) {

		char message[EXCEPTIN_MESSAGE_LENGTH+1];

		va_start(ap, cause);
		vsnprintf(message, EXCEPTIN_MESSAGE_LENGTH, cause, ap);
		va_end(ap);

		printf("%s: %s\n raised in %s at %s:%d\n", excep->name, message, func ? func : "?", file ? file : "?", line);
		
	} else {

		printf("%s: %p\n raised in %s at %s:%d\n", excep->name, excep, func ? func : "?", file ? file : "?", line);
		
	}

}


/* ** **** ******** **************** debug **************** ******** **** ** */

ntyException A = {"AException"};
ntyException B = {"BException"};
ntyException C = {"CException"};
ntyException D = {"DException"};

void *thread(void *args) {

	pthread_t selfid = pthread_self();

	Try {

		Throw(A, "A");
		
	} Catch (A) {

		printf("catch A : %ld\n", selfid);
		
	} EndTry;

	Try {

		Throw(B, "B");
		
	} Catch (B) {

		printf("catch B : %ld\n", selfid);
		
	} EndTry;

	Try {

		Throw(C, "C");
		
	} Catch (C) {

		printf("catch C : %ld\n", selfid);
		
	} EndTry;

	Try {

		Throw(D, "D");
		
	} Catch (D) {

		printf("catch D : %ld\n", selfid);
		
	} EndTry;

	Try {

		Throw(A, "A Again");
		Throw(B, "B Again");
		Throw(C, "C Again");
		Throw(D, "D Again");

	} Catch (A) {

		printf("catch A again : %ld\n", selfid);
	
	} Catch (B) {

		printf("catch B again : %ld\n", selfid);

	} Catch (C) {

		printf("catch C again : %ld\n", selfid);
		
	} Catch (D) {
	
		printf("catch B again : %ld\n", selfid);
		
	} EndTry;
	
}


#define THREADS		50

int main(void) {

	ntyExceptionInit();

	Throw(D, NULL);

	Throw(C, "null C");

	printf("\n\n=> Test1: Try-Catch\n");

	Try {

		Try {
			Throw(B, "recall B");
		} Catch (B) {
			printf("recall B \n");
		} EndTry;
		
		Throw(A, NULL);

	} Catch(A) {

		printf("\tResult: Ok\n");
		
	} EndTry;

	printf("=> Test1: Ok\n\n");

	printf("=> Test2: Test Thread-safeness\n");
#if 1
	int i = 0;
	pthread_t threads[THREADS];
	
	for (i = 0;i < THREADS;i ++) {
		pthread_create(&threads[i], NULL, thread, NULL);
	}

	for (i = 0;i < THREADS;i ++) {
		pthread_join(threads[i], NULL);
	}
#endif
	printf("=> Test2: Ok\n\n");

}

面试题：
try/catch底层如何实现的？

amanda39

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
高性能组件（4）try-catch实现

本文主要讲try catch的实现。面试微软会遇到。try/catch/finally：调试，捕获，最终try_catch用法：比如：连接数据库时有可能失败try{connect_spq(); //throw 抛出个异常string.copy(); //函数内部抛出异常}catch(){//捕获异常}finally(){//不管你有没有走，这一步一定会走}setjmp/longjmp函数：1、可以跨越函数的跳跃，可从函数A跳到函数B；2、调用longjmp函数执行完后，
复制链接

扫一扫

专栏目录