• 22-9-17学习笔记

    四次挥手状态

     

    什么是系统调用

    进程在系统上运行级别分为用户态和内核态，处于用户态的进程需要使用操作系统的功能，需要进行系统调用，切换成内核态调用操作系统的核心功能。

    死锁的四个条件

    互斥，持有并等待，非抢占，等待成环

    解除死锁的四个方案

    预防（资源分层），避免（银行家算法），检测（资源图），解除

    内存管理机制

    块式管理，分页管理，分段管理

    分页管理和分段管理的区别

    相同点：为了提高内存的利用率，较少碎片，页之间和段之间是不连续的，但是内部是连续的。

    不同点：也的大小是固定的，由操作系统决定，但段的大小不固定。

    Linux环境变量

    用户级：~/.bashrc,~/.bashrc_profile

    系统级：/etc/bashrc、/etc/environment、/etc/profile、/etc/profile.d

    环境生效的优先级：/etc/enviroment –> /etc/profile –> /etc/profile.d –> ~/.bash_profile –> /etc/bashrc –> ~/.bashrc

    一般用户级的环境在~/.bashrc_profile，系统环境变量一般在/etc/profile.d中设置。

    Linux查看性能指标常用的命令

    查看网络吞吐率，sar -n TCP 秒，表示每秒统计tcp连接数

    为什么存在DMA？

    DMA之间的IO流程：1，cpu向磁盘控制器发送消息表示要进行读数据。2，磁盘控制器准备好数据，向cpu发送中断请求。3，cpu会将磁盘控制器缓存中的数据一个字节一个字节传输到磁盘缓冲中。4，cpu再将磁盘缓冲中的数据拷贝到用户缓冲区中。5，在3,4阶段，cpu不能处理其他事情。

    DMA流程：原理：IO设备和内存之间的数据传输不需要CPU参与。1，cpu向DMA发送消息，DMA向磁盘发送消息。2，磁盘控制器准备好数据，反馈给DMA控制器。3，DMA控制器将磁盘控制器缓冲区的数据传输到磁盘缓冲区。4，DMA通知CPU，cpu将数据从内核拷贝到用户缓冲区。

    传统的文件传输的流程

    文字描述：传统的文件传输要经过用户态和内核态之间的来回拷贝，消耗较大。从磁盘中读取数据并通过网卡发送出去为例：1，通过DMA将磁盘控制器的缓冲区中拷贝到内核态的缓冲区（磁盘缓冲区）。2，从内核态的缓冲区拷贝到用户态的缓冲区。3，将用户态的缓冲区拷贝到内核态缓冲区（Socket缓冲区）。4，通过DMA将数据拷贝到网卡。

    如何实现零拷贝

    如何提高文件传输的效率，较少拷贝的次数、减少内核态和用户态切换的次数。

    1，mmap+write，mmap可以做到用户态缓冲区和内核态缓冲的数据的一个映射，可以避免了数据从内核态拷贝到用户态。流程：1，DMA将数据从磁盘控制器缓冲区拷贝的内核区。2，write操作直接将数据从磁盘缓冲区拷贝到socket缓冲区（内核态之间的数据拷贝）。3，通过DMA将数据从socket缓冲区发送到网卡。但是还是会有四次状态的切换，还会有内核态到用户态的变化。

    2，sendfile：直接将磁盘缓冲区的数据通过CPU拷贝到socket缓冲区，不存在内核态和用户态之间的切换。

    3，the-scatter-gather-DMA，直接可以认为数据从磁盘缓冲区通过DMA发送到网卡，sokcet缓冲会收到一些小字段的描述符。

    磁盘缓冲区

    磁盘缓冲区是位于内存中，存储着磁盘中部分数据，有缓存最近的数据和预读的功能。

    （直接IO）大文件传输需要禁用磁盘缓冲区，避免浪费一次的DMA传输和抢占磁盘缓冲区的热点位置。

    IO多路复用

    select：调用select，会将slect监听的文件描述符集合从用户态拷贝到内核态，由内核态遍历判断是否有事件的发生，当有事件的发生，文件描述符集合从内核态拷贝到用户态，用户态在进行遍历找到触发的事件，slect有监听文件的上线为1024.

    poll：和slect基本相同，但是监听的文件描述符的数量大于1024.

    epoll：有三个方法，epoll-create创建一个文件描述fd，epoll-ect将文件描述fd加入到内核中的红黑树中，当有事件发生的fd，会通过回调函数调入到就绪链表中。epoll-wait函数会返回所有的就绪fd。epoll分为水平模式和边缘模式，边缘模式是指调用一个epoll-wait方法，其对应的就绪文件描述符不进行处理的话，下次调用就不会返回，水平模式的话，第一次调用不进行处理的话，下次调用的时候还可以继续处理。

    常见的面试算法题

    两个线程轮流打印1-100

    1. public class Main {
    2.     static  int i = 0;
    3.     public static void main(String[] args) {
    4.         Object o = new Object();
    5.  
    6.         new Thread(()->{
    7.  
    8.                 while(i<100){
    9.                     synchronized (o) {
    10.                         if((i&1) ==0){
    11.                             System.out.println(Thread.currentThread().getName()+":"+i);
    12.                             o.notify();
    13.                             i++;
    14.                         }else {
    15.                             try {
    16.                                 o.wait();
    17.                             } catch (InterruptedException e) {
    18.                                 e.printStackTrace();
    19.                             }
    20.                         }
    21.                     }
    22.                 }
    23.  
    24.         },"偶数线程").start();
    25.         new Thread(()->{
    26.  
    27.             while(i<100){
    28.                 synchronized (o) {
    29.                     if((i&1) ==1){
    30.                         System.out.println(Thread.currentThread().getName()+":"+i);
    31.                         o.notify();
    32.                         i++;
    33.                     }else {
    34.                         try {
    35.                             o.wait();
    36.                         } catch (InterruptedException e) {
    37.                             e.printStackTrace();
    38.                         }
    39.                     }
    40.                 }
    41.             }
    42.  
    43.         },"奇数线程").start();
    44.     }
    45. }

    堆排序

    1. import java.util.Arrays;
    2.  
    3. public class Main {
    4.     static  int i = 0;
    5.     public static void main(String[] args) {
    6.        int []nums = new int[]{1,3,5,7,9,0,2,4,6,8,10};
    7.        heapSort(nums);
    8.         System.out.println(Arrays.toString(nums));
    9.     }
    10.     public static void heapSort(int []nums){
    11.         int len = nums.length;
    12.         initHeap(nums,len);
    13.         int index = len - 1;
    14.         for (int i =0;i
    15.             swap(nums,0,index);
    16.             heapfying(nums,0,index);
    17.             index --;
    18.         }
    19.     }
    20.  
    21.     private static void initHeap(int[] nums, int len) {
    22.         for (int i = len / 2  - 1 ;i>=0;i--){
    23.             heapfying(nums,i,len);
    24.         }
    25.     }
    26.  
    27.     private static void heapfying(int[] nums, int i, int len) {
    28.         int left = 2 * i + 1;
    29.         int right = 2 *i + 2;
    30.         int max_index  = i;
    31.         if(left < len &&nums[left] > nums[max_index]){
    32.             max_index = left;
    33.         }
    34.         if(right < len &&nums[right] > nums[max_index]){
    35.             max_index = right;
    36.         }
    37.         if(i != max_index){
    38.             swap(nums,i,max_index);
    39.             heapfying(nums,max_index,len);
    40.         }
    41.     }
    42.  
    43.     private static void swap(int[] nums, int i, int j) {
    44.         int tep = nums[i];
    45.         nums[i] = nums[j];
    46.         nums[j] = tep;
    47.     }
    48. }

    快排序

    1. import java.util.Arrays;
    2.  
    3. public class Main {
    4.     static  int i = 0;
    5.     public static void main(String[] args) {
    6.        int []nums = new int[]{1,3,5,7,9,0,2,4,6,8,10};
    7.         quickSort(nums,0,nums.length-1);
    8.         System.out.println(Arrays.toString(nums));
    9.     }
    10.    public static void quickSort(int []nums,int left , int right){
    11.         if(left>=right){
    12.             return;
    13.         }
    14.        int mid = partition(nums,left,right);
    15.        quickSort(nums,left,mid-1);
    16.        quickSort(nums,mid+1,right);
    17.    }
    18.    public static int partition(int []nums , int left , int right){
    19.         int flag = left ;
    20.         int index = left + 1;
    21.         for (int i=index;i<=right;i++){
    22.             if(nums[flag]>nums[i]){
    23.                 swap(nums,index,i);
    24.                 index ++;
    25.             }
    26.         }
    27.         swap(nums,index - 1,flag);
    28.         return index -1;
    29.    }
    30.    public static void swap(int[] nums, int i, int j) {
    31.         int tep = nums[i];
    32.         nums[i] = nums[j];
    33.         nums[j] = tep;
    34.     }
    35. }

    归并排序

    1.     import java.util.Arrays;
    2.     
    3.     public class Main {
    4.         static int i = 0;
    5.     
    6.         public static void main(String[] args) {
    7.             int[] nums = new int[]{1, 3, 5, 7, 9, 0, 2, 4, 6, 8, 10};
    8.             mergeSort(nums, 0, nums.length - 1);
    9.             System.out.println(Arrays.toString(nums));
    10.         }
    11.     
    12.         public static void mergeSort(int[] nums, int left, int right) {
    13.             if (left >= right) return;
    14.             int mid = left + (right - left) / 2;
    15.             mergeSort(nums, left, mid);
    16.             mergeSort(nums, mid + 1, right);
    17.             sort(nums, left, mid, right);
    18.     
    19.         }
    20.     
    21.         private static void sort(int[] nums, int left, int mid, int right) {
    22.             int i = left;
    23.             int j = mid + 1;
    24.             int index = 0;
    25.             int[] tep = new int[right - left + 1];
    26.             while (i <= mid && j <= right) {
    27.                 if (nums[i] > nums[j]) {
    28.                     tep[index++] = nums[j++];
    29.                 } else {
    30.                     tep[index++] = nums[i++];
    31.                 }
    32.             }
    33.             while (i <= mid) {
    34.                 tep[index++] = nums[i++];
    35.             }
    36.             while (j <= right) {
    37.                 tep[index++] = nums[j++];
    38.             }
    39.             index = 0;
    40.             for (i = left; i <= right; i++) {
    41.                 nums[i] = tep[index++];
    42.             }
    43.         }
    44.     
    45.         public static void swap(int[] nums, int i, int j) {
    46.             int tep = nums[i];
    47.             nums[i] = nums[j];
    48.             nums[j] = tep;
    49.         }
    50.     }

    leftBound

    1. import java.util.Arrays;
    2.  
    3. public class Main {
    4.     static int i = 0;
    5.  
    6.     public static void main(String[] args) {
    7.         int[] nums = new int[]{1, 4, 5, 7, 9, 0, 2, 4, 6, 8, 10};
    8.         Arrays.sort(nums);
    9.         System.out.println(leftBound(nums, 4));
    10.     }
    11.  
    12.     public static int leftBound(int[] nums, int key) {
    13.         int left = 0;
    14.         int right = nums.length - 1;
    15.         while (left <= right) {
    16.             int mid = left + (right - left) / 2;
    17.             if (key == nums[mid]) {
    18.                 right = mid - 1;
    19.             } else if (key > nums[mid]) {
    20.                 left = mid + 1;
    21.             } else if (key < nums[mid]) {
    22.                 right = mid - 1;
    23.             }
    24.         }
    25.         if (left >= nums.length || nums[left] != key) {
    26.             return -1;
    27.         }
    28.         return left;
    29.     }
    30. }

    rightBound

    1. import java.util.Arrays;
    2.  
    3. public class Main {
    4.     static int i = 0;
    5.  
    6.     public static void main(String[] args) {
    7.         int[] nums = new int[]{1, 4, 5, 7, 9, 0, 2, 4, 6, 8, 10};
    8.         Arrays.sort(nums);
    9.         System.out.println(rightBound(nums, 4));
    10.     }
    11.  
    12.     public static int rightBound(int[] nums, int key) {
    13.         int left = 0;
    14.         int right = nums.length - 1;
    15.         while (left <= right) {
    16.             int mid = left + (right - left) / 2;
    17.             if (key == nums[mid]) {
    18.                 left = mid + 1;
    19.             } else if (key > nums[mid]) {
    20.                 left = mid + 1;
    21.             } else if (key < nums[mid]) {
    22.                 right = mid - 1;
    23.             }
    24.         }
    25.         if (right <= 0 || nums[right] != key) {
    26.             return -1;
    27.         }
    28.         return right;
    29.     }
    30. }

    LRU

    1. import java.util.HashMap;
    2.  
    3. class Node{
    4.     String key;
    5.     Object value;
    6.     Node pre,next;
    7. }
    8.  
    9. class LRU {
    10.    HashMap map ;
    11.    Node head,tail;
    12.    int size;
    13.    int max ;
    14.    public LRU(int max){
    15.        this.max = max;
    16.        this.size = 0;
    17.        map = new HashMap<>();
    18.        head = new Node();
    19.        tail = new Node();
    20.        head.pre = null;
    21.        tail.next =null;
    22.        tail.pre = head;
    23.        head.next = tail;
    24.    }
    25.    public void add(String key , Object value){
    26.        if(map.containsKey(key)){
    27.             Node tep = map.get(key);
    28.             tep.value = value;
    29.  
    30.             Node cpre = tep.pre;
    31.             Node cnext = tep.next;
    32.             cpre.next = cnext;
    33.             cnext.pre = cpre;
    34.  
    35.             Node index = head.next;
    36.             tep.pre = head;
    37.             tep.next = index;
    38.             head.next = tep;
    39.             index.pre = tep;
    40.  
    41.        }else {
    42.            Node tep = new Node();
    43.            tep.key = key;
    44.            tep.value = value;
    45.            map.put(key,tep);
    46.  
    47.            Node index = head.next;
    48.            tep.pre = head;
    49.            tep.next = index;
    50.            head.next = tep;
    51.            index.pre = tep;
    52.  
    53.            size ++;
    54.            if (size > max){
    55.                Node t = tail.pre.pre;
    56.                String tt = tail.pre.key;
    57.                t.next = tail;
    58.                tail.pre = t;
    59.                map.remove(tt);
    60.            }
    61.        }
    62.    }
    63.    public Object get(String key){
    64.         if(!map.containsKey(key)){
    65.             return null;
    66.         }
    67.         Node res = map.get(key);
    68.  
    69.        Node cpre = res.pre;
    70.        Node cnext = res.next;
    71.        cpre.next = cnext;
    72.        cnext.pre = cpre;
    73.  
    74.        Node index = head.next;
    75.        res.pre = head;
    76.        res.next = index;
    77.        head.next = res;
    78.        index.pre = res;
    79.  
    80.        return res.value;
    81.    }
    82. }
    83.  
    84. class Main{
    85.     public static void main(String[] args) {
    86.         LRU lru = new LRU(3);
    87.         lru.add("a","a");
    88.         lru.add("c","c");
    89.         lru.add("b","b");
    90.         lru.get("a");
    91.         lru.add("d","d");
    92.         Node cv = lru.head.next;
    93.         while (cv!=lru.tail){
    94.             System.out.println(cv.key+" "+cv.value);
    95.             cv = cv.next;
    96.         }
    97.     }
    98. }
    99.

  • 相关阅读:
    SpringBoot整合Redis_自定义RedisTemplate
    高压放大器在超声马达中的应用有哪些
    社区投稿| 以安全视角，深度剖析 Sui Staking 与 LSD
    后台开发核心技术与应用实践看书笔记(三):常用STL的使用
    2Gcsv文件打不开怎么处理，使用byzer工具
    Python + Django4 搭建个人博客（二）：准备开发环境
    [附源码]计算机毕业设计JAVAssm实验教学资源管理系统
    weblogic/CVE-2018-2894文件上传漏洞复现
    7.nginx常用功能模块
    锐捷端口安全实验配置
  • 原文地址：https://blog.csdn.net/qq_41593124/article/details/126901223