【Linux实操】Linux原子操作CAS与锁实现

原创已于 2024-01-05 15:55:51 修改 · 1.1k 阅读

15 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2024-01-04 18:18:54 首次发布

本文详细介绍了互斥锁和自旋锁在多线程编程中的使用，以及原子操作、线程私有空间和cpu亲缘性的概念，通过示例展示了如何在C++中实现这些技术。同时，讨论了setjmp/longjmp在异常处理中的作用。

文章目录（末尾有惊喜！）

1、互斥锁（mutex）
2、自旋锁（spinlock）
3、原子操作
4、线程私有空间（pthread_key）
6、cpu的亲缘性（affinity）
7、setjmp/longjmp

1、互斥锁（mutex）

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define __USE_GNU

#include <sched.h>
#include <unistd.h>
#include <setjmp.h>
#include <sys/syscall.h>

#define THREAD_COUNT 30

pthread_mutex_t mutex;
pthread_spinlock_t spinlock;

void* callback(void* data){
    int* pdata = (int*)data;
    for(int i=0;i<100000;i++){
#if 1
        pthread_mutex_lock(&mutex);
        (*pdata)++;
        pthread_mutex_unlock(&mutex);
#else
    pthread_spin_lock(&spinlock);
    (*pdata)++;
    pthread_spin_unlock(&spinlock);
#endif
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_spin_init(&spinlock,PTHREAD_PROCESS_SHARED);
    pthread_t tid[THREAD_COUNT] = {0};
    int ptcount = 0;
    for(int i=0;i<THREAD_COUNT;i++){
        pthread_create(&tid[i],NULL,callback,(void*)&ptcount);
    }
    
    for(int i=0;i<100;i++){
        printf("ptcount:%d\n",ptcount);
        sleep(1);
    }
    return 0;
}

2、自旋锁（spinlock）

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define __USE_GNU

#include <sched.h>
#include <unistd.h>
#include <setjmp.h>
#include <sys/syscall.h>

#define THREAD_COUNT 30

pthread_mutex_t mutex;
pthread_spinlock_t spinlock;

void* callback(void* data){
    int* pdata = (int*)data;
    for(int i=0;i<100000;i++){
#if 0
        pthread_mutex_lock(&mutex);
        (*pdata)++;
        pthread_mutex_unlock(&mutex);
#else
    pthread_spin_lock(&spinlock);
    (*pdata)++;
    pthread_spin_unlock(&spinlock);
#endif
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_spin_init(&spinlock,PTHREAD_PROCESS_SHARED);
    pthread_t tid[THREAD_COUNT] = {0};
    int ptcount = 0;
    for(int i=0;i<THREAD_COUNT;i++){
        pthread_create(&tid[i],NULL,callback,(void*)&ptcount);
    }
    
    for(int i=0;i<100;i++){
        printf("ptcount:%d\n",ptcount);
        sleep(1);
    }
    return 0;
}

3、原子操作

int inc(int *value, int add) {

	int old;
	__asm__ volatile (
		"lock; xaddl %2, %1;"
		: "=a" (old)
		: "m" (*value), "a" (add)
		: "cc", "memory"
	);
	return old;

}

void *callback(void *data){
    int* pdata = (int*)data;
    for(int i=0;i<100000;i++){
        inc(pdata,1);
#if 0
        pthread_mutex_lock(&mutex);
        (*pdata)++;
        pthread_mutex_unlock(&mutex);
#elif 0
    pthread_spin_lock(&spinlock);
    (*pdata)++;
    pthread_spin_unlock(&spinlock);
#endif
    }
    return NULL;
}

4、线程私有空间（pthread_key）

1、pthread_key_create() 用来创建线程私有数据。该函数从 TSD 池中分配一项，将其地址值赋给 key 供以后访问使用，第2个参数，是指定销毁函数，可以设置为NULL，设置为NULL的情况下，系统使用默认的销毁函数对数据进行销毁，不为空的时候，当线程退出时（pthread_exit()），将key对应的数据调出来，去释放。
2、不论哪个线程调用了 pthread_key_create()，所创建的 key 都是所有线程可以访问的，但各个线程可以根据自己的需要往 key 中填入不同的值，相当于提供了一个同名而不同值的全局变量(这个全局变量相对于拥有这个变量的线程来说)。
3、注销一个 TSD 使用 pthread_key_delete() 函数。该函数并不检查当前是否有线程正在使用该 TSD，也不会调用清理函数(destructor function)，而只是将 TSD 释放以供下一次调用 pthread_key_create() 使用。在 LinuxThread 中，它还会将与之相关的线程数据项设置为 NULL。

key被创建之后，因为是全局变量，所以所有的线程都可以访问。各个线程可以根据需求往key中，填入不同的值，这就相当于提供了一个同名而值不同的全局变量，即一键多值。一键多值依靠的一个结构体数组，即

static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] ={{0,NULL}};

// 定义
struct pthread_key_struct
{
  /* Sequence numbers.  Even numbers indicated vacant entries.  Note
     that zero is even.  We use uintptr_t to not require padding on
     32- and 64-bit machines.  On 64-bit machines it helps to avoid
     wrapping, too.  */
  uintptr_t seq;

  /* Destructor for the data.  */
  void (*destr) (void *);
};

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define __USE_GNU

#include <sched.h>
#include <unistd.h>
#include <setjmp.h>
#include <sys/syscall.h>

#define THREAD_COUNT 3
pthread_key_t key;

typedef void* (*thread_cb)(void*);

void *func1(void *data){
    int i = 9;
    pthread_setspecific(key,&i);

    int *p = pthread_getspecific(key);
    printf("p=%d\n",*p);
    return NULL;
}

void *func2(void *data){
    char *str = "hello world";
    pthread_setspecific(key,str);

    char *ptr = pthread_getspecific(key);
    printf("ptr=%s\n",ptr);
    return NULL;
}

struct pair {
	int x;
	int y;
};

void *func3(void *data){
    struct pair p1 = {1, 2};
	pthread_setspecific(key, &p1);

    struct pair *p = (struct pair *)pthread_getspecific(key);
    printf("pair x=%d,y=%d\n",p->x,p->y);
    return NULL;
}

int main()
{
    thread_cb callback_cb[THREAD_COUNT] = {
        func1,
        func2,
        func3
    };
    pthread_key_create(&key,NULL);

    pthread_t tid[THREAD_COUNT] = {0};
    int count = 0;
    for(int i=0;i<THREAD_COUNT;i++){
        pthread_create(&tid[i],NULL,callback_cb[i],&count);
    }

    for(int i=0;i<THREAD_COUNT;i++){
        pthread_join(tid[i],NULL);
    }
    pthread_key_delete  ( key );
    return 0;
}

5、共享内存
待续

6、cpu的亲缘性（affinity）

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define __USE_GNU

#include <sched.h>
#include <unistd.h>
#include <setjmp.h>
#include <sys/syscall.h>
#define THREAD_COUNT 3

void process_affinity(int num) {
	//gettid();
	pid_t selfid = syscall(__NR_gettid);
    printf("pid=%d\n",selfid);
	cpu_set_t mask;
	CPU_ZERO(&mask);
    // cpu编号从0开始
	CPU_SET(num, &mask);

	// 也可以填入selfid
	sched_setaffinity(0, sizeof(mask), &mask);

	while(1) ;
}

int main()
{
    int num = sysconf(_SC_NPROCESSORS_CONF);
    int i = 0;
    pid_t pid = 0;
    for(int i=0;i<num/2;i++){
        pid = fork();
        if(pid<0)
            break;
    }
    if(pid == 0){
        printf("main pid=%d\n",pid);
        process_affinity(num);
    }

    while (1) usleep(1);
    return 0;
}

7、setjmp/longjmp

int setjmp(jmp_buf env);
调用setjmp将堆栈上下文保存在jmp_buf结构体中(入栈),供longjmp稍后使用（出栈）。如果直接调用返回0，如果使用保存的上下文从longjmp返回，则返回保存值非零。
void longjmp(jmp_buf env, int val);
调用longjmp程序跳转到最后一次使用相应env参数调用setjmp处，调用longjmp后setjmp不能返回0，如果longjmp第二个参数设置0，则将返回1

#include <setjmp.h>
#include <stdio.h>
 
int main(int argc, char *argv[]) {
 
        int idx = 0;
        jmp_buf env;
        int count = 0;
 
 
        count = setjmp(env);
        if (count == 0) {
                printf("count:%d\n", count);
                longjmp(env, ++idx);
        } else if (count == 1) {
                printf("count:%d\n", count);
                longjmp(env, ++idx);
        } else if (count == 2) {
                printf("count:%d\n", count);
                longjmp(env, ++idx);
        } else {
                printf("other count:%d\n",count);
        }
 
        return 0;
}



#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <stdarg.h>

#include <pthread.h>
#include <setjmp.h>

#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;

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 {							\
			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);
			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");

}

接下来我将给各位同学划分一张学习计划表！

学习计划

那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：

阶段一：初级网络安全工程师

接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。

综合薪资区间6k~15k

1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）

那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？

阶段二：中级or高级网络安全工程师（看自己能力）

综合薪资区间15k~30k

7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。

零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；

Python编程学习，学习内容包含：语法、正则、文件、网络、多线程等常用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。