linux程序设计复习总结（五）数据管理

1.每个在Linux系统中运行的程序都只能看到属于自己的内存映像，不同的程序看到的内存映像不同。只有操作系统知道物理内存是如何安排的，它不仅为用户程序管理内存，同时也为用户程序提供彼此之间的隔离保护。

2.调用free时使用的指针参数必须是指向由malloc、calloc或realloc调用所分配的内存。

3.mollc申请一定大小的内存空间，calloc为结构数组分配内存，参数结构个数和大小，realloc用来改变已经分配的内存块的大小。free释放内存。要确保一旦内存被重新分配之后，你必须使用新的指针而不是使用realloc调用前的那个指针去访问内存。

void *malloc(size_t size);
void *calloc(size_t number_of_elements,size_t element_size);
void *realloc(void *existing_memory,size_t new_size):
void free(void *ptr_to_memory);

4.如果一个程序在它执行时，只需独占某个资源一段很短的时间，通常被称为临界区，它就需要在进入临界区之前使用open系统调用创建锁文件，然后在退出临界区时用unlink系统调用删除该锁文件。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>

int main()
{
    int file_desc;
    int save_errno;

    file_desc = open("/tmp/LCK.test", O_RDWR | O_CREAT | O_EXCL, 0444);
    if (file_desc == -1) {
        save_errno = errno;
        printf("Open failed with error %d\n", save_errno);
    }
    else {
        printf("Open succeeded\n");
    }
    return 0;
}

第一次执行成功，第二次因为文件已存在会失败。

 

 

 

5.区域锁定

如果需要一些协调方法来提供对同一个文件的并发访问，可以通过锁定文件区域的方法来解决这个问题，文件中的某个特定部分被锁定了，但其他程序可以访问这个文件中的其他部分。这被称为文件段锁定或文件区域锁定。

int fcntl(int fildes,int command,struct flock *flock_structure);

fildes:文件描述符

command：

F_GETLK:试探一下我能不能上个读锁或者写锁，此时结构体会带回该文件已有锁的状态信息

F_SETLK:上锁或者解锁，结构体带去锁信息

F_SETLKW:不给上锁或者收到信号之前一直赖着不返回

struct flock:

short l_type:F_RDLCK读（共享）锁，F_UNLCK(解锁)，F_WRLCK写(独占)锁

short l_whence:SEEK_SET、SEEK_CUR、SEEK_END（l_start的相对偏移位置：起点，当前，文件尾）

off_t l_start:将要上锁的起点位置

off_t l_len:上锁区域的长度

pid_t l_pid:上锁进程

void show_lock_info(struct flock *to_show) 
{
    printf("\tl_type %d, ", to_show->l_type);
    printf("l_whence %d, ", to_show->l_whence);
    printf("l_start %d, ", (int)to_show->l_start);        
    printf("l_len %d, ", (int)to_show->l_len);
    printf("l_pid %d\n", to_show->l_pid);
}

int getlock_test()
{
    const char *test_file = "/tmp/test_lock";
    #define SIZE_TO_TRY 5
	int file_desc;
    int res;
    struct flock region_to_test;
    int start_byte = 10;
    region_to_test.l_type = F_WRLCK;
    region_to_test.l_whence = SEEK_SET;
    region_to_test.l_start = start_byte;
    region_to_test.l_len = SIZE_TO_TRY;
    region_to_test.l_pid = -1;     

	file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
    if (!file_desc) 
	{
        fprintf(stderr, "Unable to open %s for read/write", test_file);
        exit(EXIT_FAILURE);
    }
    res = fcntl(file_desc, F_GETLK, &region_to_test);
    if (res == -1) 
	{
        fprintf(stderr, "F_GETLK failed\n");
        exit(EXIT_FAILURE);
    }
    if (region_to_test.l_pid != -1) 
	{
        printf("Lock would fail. F_GETLK returned:\n");
        show_lock_info(&region_to_test);
    }
    else 
	{
        printf("F_WRLCK - Lock would succeed\n");
    }

	return 0;
}

int getlock_test() 
{
    int file_desc;
    struct flock region_1;
    const char *test_file = "/tmp/test_lock";
    int res;

    file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
    if (!file_desc) {
        fprintf(stderr, "Unable to open %s for read/write\n", test_file);
        exit(EXIT_FAILURE);
    }

    region_1.l_type = F_RDLCK;
    region_1.l_whence = SEEK_SET;
    region_1.l_start = 10;
    region_1.l_len = 20; 
    
    res = fcntl(file_desc, F_SETLK, &region_1);
    if (res == -1) fprintf(stderr, "Failed to lock region 1\n");    
    
    close(file_desc);
    return 0;
}

6.死锁

两个程序同时启动。程序A锁定字节2，而程序B锁定字节1。然后程序A尝试锁定字节1，但因为这个字节已经被程序B锁定，所以程序A将在那里等待。接着程序B尝试锁定字节2，但因为这个字节已经被程序A锁定，所以程序B也将在那里等待。这种两个程序都无法继续执行下去的情况，就被称为死锁。

数据库部分待补充