One thread gets memory and another thread releases memory, resulting in memory leakage

Using Junzheng x2000 Platform time , The memory footprint of the application will gradually increase , After that, the application will eventually be kill fall . By analyzing the reasons, it is found that , Apply for memory in a thread , The requested memory is released in another thread , After the release is completed, the thread ends , This operation will cause memory leakage .

The producer's problem is simple , In theory, there should be no such problem , So in x86 and arm Next test , No similar situation was found , Then make sure it's Junzheng x2000 Platform issues . Put the question to Junzheng , At present, you are investigating .

Here is my simple test code , You can test your own platform ：

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


static pthread_mutex_t addr_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t free_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *addr;
static int is_free;

static void malloc_test(int size)
{
	pthread_mutex_lock(&addr_mutex);
	addr = malloc(size);
	printf("==========================\n");
	printf("malloc: %p\n", addr);
	pthread_mutex_unlock(&addr_mutex);
}

static void free_test(void)
{
	pthread_mutex_lock(&addr_mutex);
	printf("free: %p\n", addr);
	printf("==========================\n");
	free(addr);
	pthread_mutex_unlock(&addr_mutex);
}

/*
 *  There is no memory leak 
 */
void test1()
{
	while (1) {
		malloc_test(260);
		free_test();
		usleep(100000);
	}
}


static void *free2_thread(void *arg)
{
	pthread_detach(pthread_self());

	free_test();

	pthread_mutex_lock(&free_mutex);
	is_free = 0;
	pthread_mutex_unlock(&free_mutex);
	
	return NULL;
}

/*
 *  Allocate memory in a thread , Free memory in another thread , After release , End of release thread , As long as the memory allocation is less than 517 There is a memory leak 
 * cat proc/ Process number /status
 */
void test2()
{
	pthread_t thread;

	while (1) 
	{
		malloc_test(516);

		pthread_mutex_lock(&free_mutex);
		is_free = 1;
		pthread_mutex_unlock(&free_mutex);

		pthread_create(&thread, NULL, free2_thread, NULL);

		while (is_free) {
			usleep(1000);
		}
	}	
}

static void *free3_thread(void *arg)
{
	pthread_detach(pthread_self());

	while (1) {
		free_test();

		pthread_mutex_lock(&free_mutex);
		is_free = 0;
		pthread_mutex_unlock(&free_mutex);
		usleep(10000);
	}

	return NULL;
}

/*
 *  Allocate memory in a thread , Free memory in another thread ,  When the release thread does not end , There is no memory leak 
 * cat proc/ Process number /status
 */
void test3()
{
	pthread_t thread;

	pthread_create(&thread, NULL, free3_thread, NULL);

	while (1) 
	{
		malloc_test(516);

		pthread_mutex_lock(&free_mutex);
		is_free = 1;
		pthread_mutex_unlock(&free_mutex);

		while (is_free) {
			usleep(1000);
		}
	}	
}


void main(void)
{
	//test1();
	test2();
	//test3();
}