使用setrlimit控制进程使用系统内存

本文通过C语言实现了一个简单的程序来设置进程的最大内存使用限制,并通过不断分配内存直至失败来验证设置的有效性。该程序利用了POSIX的rlimit机制来控制进程的资源消耗。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <errno.h>

int main(void)
{
	int nMemoryLimit = 1024 * 1024 * 5;//5M

	struct rlimit memoryL;

	getrlimit(RLIMIT_AS, &memoryL);
	printf("before set mem:%lu,%lu\r\n", (unsigned long)memoryL.rlim_cur, (unsigned long)memoryL.rlim_max);

	memoryL.rlim_cur = nMemoryLimit;
	setrlimit(RLIMIT_AS ,&memoryL);

	getrlimit(RLIMIT_AS, &memoryL);
	printf("after set mem:%lu,%lu\r\n", (unsigned long)memoryL.rlim_cur, (unsigned long)memoryL.rlim_max);

	int i = 0;
	while(1)
	{
		i++;
		//当进程内存达到最大值时,malloc calloc返回NULL,记录错误errno=ENOMEM
		errno  = 0;
		char *psString = (char *)calloc(1, 1024);
		if(NULL == psString)
		{
			//printf("errno=%d, ENOMEM=%d\r\n", errno, ENOMEM);
		}
		else
		{
			printf("success, %d\r\n", i);
		}
	}
	return 0;
}


<think>好的,用户现在想了解进程使用方法,特别是与编程或系统开发相关的部分。根据之前的对话历史,用户之前询问了C++线程的使用方法,现在转向进程。需要结合用户提供的引用内容,但要注意引用是关于Python的,而用户之前的讨论是C++,但用户现在可能对进程的通用概念和实现方法感兴趣,可能不限定语言。需要先判断用户的需求是否特定于某种语言,但用户的问题没有明确指定,所以应该涵盖通用方法和常见语言的示例,比如C++和Python,同时结合之前的C++线程内容进行对比。 首先,用户提供的引用1和2提到了Python中的多线程和多进程,线程池和进程池。但用户现在的问题是关于进程使用,所以需要重点放在进程上,而不是线程。需要解释进程的概念,与线程的区别,创建进程的方法,进程间通信,同步机制,以及进程池的使用。 用户之前的C++线程回答中涉及了线程创建、同步、注意事项等,现在需要类似的流程来讲解进程。可能需要比较进程和线程的区别,尤其是在不同语言中的实现,比如C++和Python。同时,用户可能对进程的实际应用场景和性能优化感兴趣。 需要确保回答结构清晰,分点说明,包括基本概念、创建方法、通信机制、同步方法、进程池、注意事项和示例代码。示例代码可能需要涵盖不同语言,如C++的fork()和Python的multiprocessing模块。同时,要注意用户可能对系统开发中的进程管理,如资源分配、错误处理等有进一步的问题。 可能的问题点:用户是否了解进程与线程的根本区别?是否需要先解释这些概念?根据引用2,用户可能已经有一些基础,但需要更深入的使用方法。需要确认回答中的示例是否足够详细,并覆盖不同场景,比如进程间通信的不同方法(管道、队列、共享内存等)。 另外,用户可能关心进程在实际项目中的应用,比如如何利用多进程提高计算效率,如何处理进程间的数据隔离,以及如何避免常见问题如僵尸进程等。需要涵盖这些点,并在注意事项中强调。 最后,生成的相关问题需要引导用户深入思考,比如进程与线程的选择、进程间通信的效率比较、进程池的优化等。确保问题与回答内容紧密相关,帮助用户进一步学习。</think>### 进程使用方法详解(附C++/Python代码示例) #### 一、进程核心概念 1. **进程与线程区别** - 进程是操作系统资源分配的最小单位,线程是CPU调度的最小单位[^2] - 进程拥有独立内存空间,线程共享进程内存 - 进程创建销毁开销大(约MB级内存),线程开销小(约KB级) 2. **适用场景** - CPU密集型任务(科学计算、图像处理) - 需要内存隔离的安全场景 - 利用多核CPU并行计算 --- #### 二、进程创建方法 1. **C++标准方法(Unix/Linux)** 使用`fork()`系统调用(注意:Windows不可用): ```cpp #include <unistd.h> #include <sys/wait.h> int main() { pid_t pid = fork(); // 创建子进程 if (pid == 0) { // 子进程执行分支 execlp("/bin/ls", "ls", "-l", NULL); } else { // 父进程执行分支 wait(NULL); // 等待子进程结束 cout << "子进程完成" << endl; } return 0; } ``` 2. **Python跨平台方法** 使用`multiprocessing`模块: ```python import multiprocessing def task(name): print(f"子进程 {name} 执行") if __name__ == "__main__": p = multiprocessing.Process(target=task, args=("worker",)) p.start() p.join() ``` --- #### 三、进程间通信(IPC) | 通信方式 | C++实现 | Python实现 | |----------------|----------------------------------|---------------------------------| | 管道(Pipe) | `pipe()`系统调用 | `multiprocessing.Pipe()` | | 共享内存 | `shm_open()`+`mmap()` | `multiprocessing.Array()` | | 消息队列 | `msgget()`系统调用 | `multiprocessing.Queue()` | | 信号量 | `sem_init()` | `multiprocessing.Semaphore()` | **C++共享内存示例**: ```cpp #include <sys/mman.h> int main() { int* shared = (int*)mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); if(fork() == 0) { *shared = 100; // 子进程写入 exit(0); } else { wait(NULL); cout << "共享值: " << *shared << endl; // 输出100 munmap(shared, sizeof(int)); } return 0; } ``` --- #### 四、进程同步机制 1. **互斥锁** Python使用进程锁: ```python from multiprocessing import Process, Lock def safe_print(lock, msg): with lock: print(msg) if __name__ == "__main__": lock = Lock() procs = [Process(target=safe_print, args=(lock, f"消息{i}")) for i in range(5)] for p in procs: p.start() for p in procs: p.join() ``` 2. **信号量控制** C++实现进程间信号量: ```cpp #include <semaphore.h> sem_t *sem = sem_open("/mysem", O_CREAT, 0644, 1); // 创建命名信号量 void process_task() { sem_wait(sem); // 临界区操作 sem_post(sem); } ``` --- #### 五、进程池技术 1. **Python进程池** 自动管理进程生命周期: ```python from multiprocessing import Pool def compute_square(n): return n * n if __name__ == "__main__": with Pool(4) as pool: # 创建4进程池 results = pool.map(compute_square, range(10)) print(results) # [0,1,4,9,...,81] ``` 2. **C++17并行算法** 使用标准库实现并行处理: ```cpp #include <execution> #include <vector> int main() { std::vector<int> data(1000000, 2); std::for_each(std::execution::par, // 并行策略 data.begin(), data.end(), [](int& n){ n *= n; }); return 0; } ``` --- #### 六、生产环境注意事项 1. **僵尸进程防治** - 父进程必须调用`wait()`/`waitpid()` - 使用信号处理`SIGCHLD` ```cpp signal(SIGCHLD, [](int sig) { while(waitpid(-1, NULL, WNOHANG) > 0); }); ``` 2. **资源限制监控** - 使用`getrlimit()`/`setrlimit()`控制资源 - 监控内存使用防止OOM 3. **优雅终止方案** 设计进程信号处理机制: ```python import signal def handler(signum, frame): print("收到终止信号,清理资源...") exit(0) signal.signal(signal.SIGTERM, handler) ``` --- ### 七、性能优化方向 1. **负载均衡** - 动态任务分配算法 - 使用工作窃取(Work Stealing)模式 2. **数据局部性优化** - 减少进程间通信频率 - 批量传输代替频繁小数据交换 3. **NUMA架构优化** ```bash # Linux绑定进程到NUMA节点 numactl --cpubind=0 --membind=0 ./program ``` --- ### 八、完整案例:分布式任务处理系统 **架构设计**: ``` 主进程 ├── 任务分配进程使用消息队列) ├── 监控进程(资源统计) └── Worker进程池(动态扩容) ``` **Python实现核心逻辑**: ```python import multiprocessing as mp from queue import Empty class DistributedSystem: def __init__(self, n_workers): self.task_queue = mp.Queue() self.result_queue = mp.Queue() self.workers = [mp.Process(target=self.worker) for _ in range(n_workers)] def worker(self): while True: try: task = self.task_queue.get(timeout=5) result = process_task(task) self.result_queue.put(result) except Empty: break def submit(self, tasks): for t in tasks: self.task_queue.put(t) def get_results(self): return [self.result_queue.get() for _ in range(self.result_queue.qsize())] ``` ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值