操作系统 on Kingcanfish 的小星球 🪐

一些学习知识点

Thu, 22 Oct 2020 10:32:26 +0800

操作系统

LRU

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。新数据插入到链表头部；每当缓存命中（即缓存数据被访问），则将数据移到链表头部；当链表满的时候，将链表尾部的数据丢弃。

哈希表+ 双向链表的实现

//LRUCache 缓存
type LRUCache struct {
	size     int						// 缓存当前存在的元素数量
	capacity int						// 缓存容量
	cache    map[int]*Linkednode		// 哈希表,用于快速访问
	head     *Linkednode
	tail     *Linkednode
}

// Linkednode 数据
type Linkednode struct {
	key   int
	value int
	pre   *Linkednode
	next  *Linkednode
}

func initLinkednode(key, value int) *Linkednode {
	return &Linkednode{
		key:   key,
		value: value,
	}
}

//Constructor 构造器
func Constructor(capacity int) LRUCache {
	l := LRUCache{
		size:     0,
		capacity: capacity,
		cache:    make(map[int]*Linkednode),
		head:     initLinkednode(0, 0),
		tail:     initLinkednode(0, 0),
	}
	l.head.next = l.tail
	l.tail.pre = l.head
	return l

}

func (this *LRUCache) Get(key int) int {
	if _, ok := this.cache[key]; !ok {
		return -1
	}

	this.moveToHead(this.cache[key])
	return this.cache[key].value

}

// Put 放入新节点
func (this *LRUCache) Put(key int, value int) {
	if _, ok := this.cache[key]; ok {
		this.cache[key].value = value
		this.moveToHead(this.cache[key])
		return
	}
	newNode := initLinkednode(key, value)
	this.cache[key] = newNode
	this.addToHead(newNode)
	this.size++
	if this.size > this.capacity {
		 node := this.deleteTail()
		delete(this.cache, node.key)
		this.size--
	}
	return
}

//addToHead 将这个节点添加到双向链表的头部
func (this *LRUCache) addToHead(node *Linkednode) {
	node.pre = this.head
	node.next = this.head.next
	this.head.next.pre = node
	this.head.next = node
	return
}

func (l *LRUCache) moveToHead(node *Linkednode) {
    //先删掉这个元素再把它放入头部
	l.deleteNode(node)
	l.addToHead(node)
	return
}

func (l *LRUCache) deleteTail() *Linkednode {
	node := l.tail.pre
	l.deleteNode(node)
	return node

}

func (l *LRUCache) deleteNode(node *Linkednode) {
	node.next.pre = node.pre
	node.pre.next = node.next
	return
}

select, poll, epoll

区别

内存

为什么虚拟内存会远大于物理内存

网络

http

https
- HTTPS通信的建立机制
- 客户端发起 HTTPS 请求，服务端返回证书，客户端对证书进行验证，验证通过后本地生成用于改造对称加密算法的随机数，通过证书中的公钥对随机数进行加密传输到服务端，服务端接收后通过私钥解密得到随机数，之后的数据交互通过对称加密算法进行加解密。
post和get的区别
接口请求头有哪些参数，说五个并解释意思

tcp

滑动窗口
滑窗过小怎么办，提示有个算法
TCP有哪些机制可以完成可靠传输
2次握手行不行?为什么要3次
为什么要2倍timewait
tcp半连接队列

数据库

mysql

MySQL 语句执行的过程
MySQL 的缓存会失效吗
MySQL 主从同步机制，如果同步失败会怎么样？
MySQL 事务隔离界别有哪些？哪些情况下分别采取什么样的隔离级别

redis

常见数据结构
过期数据删除
- 懒删除 + 定期删除 懒删除:访问时判断有没有过期, 过期则删除,定期删除:定期遍历一部分键,过期则删除
内存满了怎么办

算法

判断是否环链表，要找环位置怎么处理？
- 快慢指针,快指针2步,慢指针1步 , 相遇则有环 , 在相遇的地方再在链表头放一个指针ptr ,和慢指针一起走,他们一定会在入环的地方相遇
如果一个很大的array中只有一个数出现1次，其他都出现2次。要找这个数。怎么做
- 将所有数字进行异或,最后得到的值就是只出现一次的数
找出一个很大array中出现次数超过一半的数，怎么做？
- 排序,这个数一定在中间
- 摩尔投票法: 投票法简单来说就是不同则抵消，占半数以上的数字必然留到最后。
找一个很大array中出现第k小的数怎么做？
- topK 问题建立一个容量为K的小顶堆,最后一个数就是 topK小 ,也可以说是优先队列->手写堆排序,请

生产者消费者模型与信号量

Sat, 26 Sep 2020 07:35:26 +0800

最近在看操作系统有关线程同步的章节,关于 信号量 , 条件变量 , 互斥量 之间的具体区别有点分不清楚,所以在这里记录一下

信号量 , 条件变量, 互斥量

首先信号量,条件变量,互斥量都是有关操作系统线程同步的有关知识,我相信在每一本操作系统教材上都有提到过,下面我写一下我自己理解

互斥量 : 互斥量总是和互斥锁相联系,我们所说的互斥锁本质上就是锁住一个互斥量,所以互斥量只有两种情况
- 被上锁状态
- 解锁状态
- 所以就可以用0 , -1 表示 , 0 表示自由, 没有被上锁, -1 表示已经被上锁
信号量: 信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。
- 按我的理解,信号量就是用来表示某个资源可以被其他线程同时获取的数量, 比如信号量为 5,可以允许对做5个线程对资源进行获取,当然每个线程获取之前,必须将信号量减一, 而每个线程释放之后,有必须将信号量加一,以供其他资源获取.
- 当信号量初始化最大为1时,此时只允许同时有一个线程对资源进行操作, 那么也就是互斥了,那么这就形成了一把互斥锁,所以 二值信号量 我们可以当做一把锁来用 .
条件变量 : 条件变量 ( cond ) 是在多线程程序中用来实现"等待 –> 唤醒" 逻辑常用的方法。条件变量利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使“条件成立”。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。线程在改变条件状态前必须首先锁住互斥量，函数 pthread_cond_wait 把自己放到等待条件的线程列表上，然后对互斥锁解锁(这两个操作是原子操作)。在函数返回时，互斥量再次被锁住。
- 众所周知,如果要防止多个线程对资源进行竞争, 最简单粗暴的方法就是对该资源进行上锁,但是用个问题,一旦某个线程想要获取某个上锁的线程,它只能 等待 -> 尝试获取 -> 失败 -> 尝试获取 -> 等待 ,如此的循环自旋是比较消耗 CPU 资源的,所以就需要条件变量.
- 条件变量的作用就是让获取不过锁的线程休眠,然后在释放锁/条件变量的时候唤醒休眠的线程.
- 所以条件变量 = 上锁/解锁 + 休眠/唤醒线程的组合操作 , 它把这两个操作放在一起,构成了一个原子操作.
互斥量是信号量的一种特例，互斥量的本质是一把锁。A mutex is basically a lock that we set (lock) before accessing a shared resource and release (unlock) when we’re done

基于信号量的生产者消费者模型

#include <string.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <time.h>

sem_t empty,full;

pthread_mutex_t mutex;

int buffer_count = 0; //全局变量,管道内 产品数目大小

void *producer (void *arg); //定义生产者

void *consumer (void *arg); // 定义消费者


int main(int argc, char **argv) {
    srand((unsigned)time(NULL));  //初始化随机种子
    pthread_t p_prod; // 生产者线程
    pthread_t p_cons; // 消费者线程
    pthread_mutex_init(&mutex, NULL); //  初始化互斥量
    sem_init(&full,0, 0);  //初始化 full 信号量
    sem_init(&empty, 0 ,5 ); // 初始化 empty empty 信号量
    // 创建生产者和消费者线程
    if (pthread_create(&p_prod, NULL, producer, NULL) != 0) 
    {
        printf("thread producter create failed. \n");
    }
    if (pthread_create(&p_cons, NULL, consumer, NULL) != 0) 
    {
        printf("thread consumer create failed. \n");       
    }

    pthread_join(p_cons, NULL);
    pthread_join(p_prod, NULL);
    return 0;
}

void *producer(void *arg) {
    while (1) {
        sem_wait(&empty); // wait 使 empty 信号量 减1 ,当empty 减为 -1 时,线程休眠
        pthread_mutex_lock(&mutex);
        printf("producer put an element..");
        buffer_count++;
        printf("now buffer_count is %d\n", buffer_count);
        pthread_mutex_unlock(&mutex);
        sem_post(&full); // post 使 full 信号量加1 唤醒消费者可以消费
        sleep(rand() % 3 ); //用于三秒内随机控制时间
    }
}


void *consumer (void *arg) {
    while (1) {
        sem_wait(&full); // wait 使 full 信号量 减一 ,为-1 时 说明 负的full 就是 empty 所以休眠
        pthread_mutex_lock(&mutex);
        printf("consumer get an element..");
        buffer_count--;
        printf("now buffer_count is %d\n", buffer_count);
        pthread_mutex_unlock(&mutex);
        sem_post(&empty); // post 使 empty 信号量 加1 ,生产者可以生产
        sleep(rand() % 3);//用于三秒内随机控制时间
    }
}

执行结果:

consumer get an element..now buffer_count is 0
producer put an element..now buffer_count is 1
producer put an element..now buffer_count is 2
consumer get an element..now buffer_count is 1
consumer get an element..now buffer_count is 0
producer put an element..now buffer_count is 1
consumer get an element..now buffer_count is 0
producer put an element..now buffer_count is 1
consumer get an element..now buffer_count is 0
producer put an element..now buffer_count is 1
producer put an element..now buffer_count is 2
producer put an element..now buffer_count is 3