linux 安装指定版本MySql

由于工作环境、生产环境,我们使用的操作系统为为CentOS6.9,所需mysql版本为5.7,目前CentOS6.x系统默认mysql版本为5.1,这个版本是实在是太旧了。

彻底卸载系统已经安装的旧版本

    阅读全文

    TCP 三次握手和四次挥手

    首先需要了解的知识

    • TCP的包是没有IP地址的,那是IP层上的事。但是有源端口和目标端口。
    • 一个TCP连接需要四个元组来表示是同一个连接(src_ip, src_port, dst_ip, dst_port)准确说是五元组,还有一个是协议。但因为这里只是说TCP协议,所以,这里我只说四元组。

    阅读全文

    网易互娱面试总结

    现场二面技术总监面试

    这个人看起来挺和善的,实际上还是有一套的,让你写代码,然后眼睛编译给你指出错误,然后修改,然后他就去玩手机了…

    阅读全文

    linux 内核RingBuffer实现

    实现方式非常巧妙,刚开始看的有点奇怪,当发现实现原理后惊讶了一番..

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    /**@brief 仿照linux kfifo写的ring buffer
    * ring_buffer.h
    * */

    #ifndef KFIFO_HEADER_H
    #define KFIFO_HEADER_H

    #include <inttypes.h>
    #include <string.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <errno.h>
    #include <assert.h>

    //判断x是否是2的次方
    #define is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))
    //取a和b中最小值
    #define min(a, b) (((a) < (b)) ? (a) : (b))

    struct ring_buffer
    {
    void *buffer; //缓冲区
    uint32_t size; //大小
    uint32_t in; //入口位置
    uint32_t out; //出口位置
    pthread_mutex_t *f_lock; //互斥锁
    };
    //初始化缓冲区
    struct ring_buffer* ring_buffer_init(void *buffer, uint32_t size, pthread_mutex_t *f_lock)
    {
    assert(buffer);
    struct ring_buffer *ring_buf = NULL;
    if (!is_power_of_2(size))
    {
    fprintf(stderr,"size must be power of 2.\n");
    return ring_buf;
    }
    ring_buf = (struct ring_buffer *)malloc(sizeof(struct ring_buffer));
    if (!ring_buf)
    {
    fprintf(stderr,"Failed to malloc memory,errno:%u,reason:%s",
    errno, strerror(errno));
    return ring_buf;
    }
    memset(ring_buf, 0, sizeof(struct ring_buffer));
    ring_buf->buffer = buffer;
    ring_buf->size = size;
    ring_buf->in = 0;
    ring_buf->out = 0;
    ring_buf->f_lock = f_lock;
    return ring_buf;
    }
    //释放缓冲区
    void ring_buffer_free(struct ring_buffer *ring_buf)
    {
    if (ring_buf)
    {
    if (ring_buf->buffer)
    {
    free(ring_buf->buffer);
    ring_buf->buffer = NULL;
    }
    free(ring_buf);
    ring_buf = NULL;
    }
    }

    //缓冲区的长度
    uint32_t __ring_buffer_len(const struct ring_buffer *ring_buf)
    {
    return (ring_buf->in - ring_buf->out);
    }

    //从缓冲区中取数据
    uint32_t __ring_buffer_get(struct ring_buffer *ring_buf, void * buffer, uint32_t size)
    {
    assert(ring_buf || buffer);
    uint32_t len = 0;
    size = min(size, ring_buf->in - ring_buf->out);
    /* first get the data from fifo->out until the end of the buffer */
    len = min(size, ring_buf->size - (ring_buf->out & (ring_buf->size - 1)));
    memcpy(buffer, ring_buf->buffer + (ring_buf->out & (ring_buf->size - 1)), len);
    /* then get the rest (if any) from the beginning of the buffer */
    memcpy(buffer + len, ring_buf->buffer, size - len);
    ring_buf->out += size;
    return size;
    }
    //向缓冲区中存放数据
    uint32_t __ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
    {
    assert(ring_buf || buffer);
    uint32_t len = 0;
    size = min(size, ring_buf->size - ring_buf->in + ring_buf->out);
    /* first put the data starting from fifo->in to buffer end */
    len = min(size, ring_buf->size - (ring_buf->in & (ring_buf->size - 1)));
    memcpy(ring_buf->buffer + (ring_buf->in & (ring_buf->size - 1)), buffer, len);
    /* then put the rest (if any) at the beginning of the buffer */
    memcpy(ring_buf->buffer, buffer + len, size - len);
    ring_buf->in += size;
    return size;
    }

    uint32_t ring_buffer_len(const struct ring_buffer *ring_buf)
    {
    uint32_t len = 0;
    pthread_mutex_lock(ring_buf->f_lock);
    len = __ring_buffer_len(ring_buf);
    pthread_mutex_unlock(ring_buf->f_lock);
    return len;
    }

    uint32_t ring_buffer_get(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
    {
    uint32_t ret;
    pthread_mutex_lock(ring_buf->f_lock);
    ret = __ring_buffer_get(ring_buf, buffer, size);
    //buffer中没有数据
    if (ring_buf->in == ring_buf->out)
    ring_buf->in = ring_buf->out = 0;
    pthread_mutex_unlock(ring_buf->f_lock);
    return ret;
    }

    uint32_t ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
    {
    uint32_t ret;
    pthread_mutex_lock(ring_buf->f_lock);
    ret = __ring_buffer_put(ring_buf, buffer, size);
    pthread_mutex_unlock(ring_buf->f_lock);
    return ret;
    }
    #endif

    阅读全文