1.操作系统 | 进程之间如何通信线程之间如何通信

孩子直接傻了。操作系统学了跟白学一样，这个好复杂没有考就没有复习。这里就列出通信方式名字了，详细原理看搬运博客吧 -> 参考博客

进程之间通信

管道
- 普通管道PIPE
- 命令管道s_pipe
- 命名管道FIFO(有名管道/无名管道)
信号量
它是一个计数器，记录资源能被多少个进程同时访问。用于控制多进程对临界资源的访问（同步)），并且是非负值。主要作为进程间以及同一进程的不同线程间的同步手段。
- 临界资源：同一时刻，只能被一个进程访问的资源
- 临界区：访问临界资源的代码区
- 原子操作：任何情况下不能被打断的操作。
消息队列
消息队列是消息的链表，是存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区受限等特点，允许不同进程将格式化的数据流以消息队列形式发送给任意进程。
共享内存
共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。
socket通信

线程之间通信 ->参考博客 | 参考博客2

同步
指多个线程通过synchronized关键字这种方式来实现线程间的通信。
while轮询的方式
使用Object类的wait() 和 notify() 方法
基本LockSupport实现线程间的阻塞和唤醒

2.算法 | 给定一个只包括 []{}() 的字符串，判断字符串是否有效。

输入: "()"    输出: true
输入: "[()]"  输出: true
输入: "{()]"  输出: false

解决思路：其实就是简单的入栈出栈操作，入左边的括号，当是右边的括号的时候看栈顶能否匹配。代码丑陋且不简洁但是意思意思吧（泪目)毕竟差点连链表都忘了

class Solution {

public:
bool isValid(string s) {

    stack<char> mystack;
    string::iterator it;
    
    for(it=s.begin(); it != s.end();)
    {
        
        if(*it=='('|| *it=='[' || *it=='{')//为左括号的时候压栈
        {
            mystack.push(*it);
        }
        else
        {
            if(mystack.size()==0)
            return false;
            
            char kuohao = mystack.top();//获取栈顶值
            mystack.pop();//出栈
            if(*it ==')'){
                 if(kuohao != '(')return false;
                }
            else if(*it==']'){
                if(kuohao != '[')return false;
                }
            else if(*it=='}'){
                if(kuohao != '{')return false;
            }
        }
        it ++;
    }
    if(mystack.size()!=0)
    return false;
    else
    return true;

}
};

3.js | 数组转换 | 把一个一维数组(数据只包含Number)[2,3,4]转为234你有哪些方式

定义字符串s='',循环数组，进行s++;
string s = array.toString()或者toLocaleString() 方法转换成按照逗号拼接的字符串，再使用s=s.replace(/,/g,'')方法去除逗号拼接
string s = array+[] 按照数组链接防止转换成按照逗号拼接的字符串，再同样使用s=s.replace(/,/g,'')方法去除逗号拼接
string s = array.join("")，以空字符串拼接数组
array.reduce((a,b)=>a+b, "") ，用函数进行逐个项的拼接。看了谭磊的博客的补充

4.js | 数组展平 | 一个多维数组,转换成一维数组

转字符串 let s=arr.join(',').split(',');首先按照join方法将数组按照逗号拼接，在用split方法分割数组。但是数组中存储数字的形式为字符串，需要map进行再次遍历。let arrnum = s.map(item=>{ return Number(item); });
array.flat() 或者 [].concat(array)方法可以将二维数组转换为一维数组，但更多维数组将保留数组选项。如果知道数组为几维数组，则可以使用[1, 2, [3, [4, 5]]].flat(2)方法传递降维次数

使用递归方法进行数组的递归，并用Object.prototype.toString.call()判断数据类型，如果是array就进行递归

function unid1(arr){
    for(let item of arr){
        if(Object.prototype.toString.call(item).slice(8, -1)==='Array'){
            unid1(item);
        }else{
            result.push(item);
        }
    }
    return result;
}

同样递归的原理,但是使用reduce + concat

(function(origin){
  function flat_deep_with_reduce(arr){
      //首先reduce 进行返回值sum与每个current进行函数过后的来及
      //使用Array.isArray(item)方法判断current项是否为数组。
      //如果是数组就递归，否则直接concat扁平化当前项进行拼接
      return arr.reduce( (sum,current) => Array.isArray(current) ? sum.concat(flat_deep_with_reduce(current) ) :  sum.concat(current) , [] );
  }
  
  let result = flat_deep_with_reduce(origin);
  console.log(result);
  })([1,2,[3,4,[5,6],7],8]);

使用堆栈。其本质依旧是对每一项进行判断

(function(origin){
  let stack = [...origin] ;
  let converted = [];

  while(stack.length){
      let item = stack.pop();    //从堆栈底部 弹出元素
      if(Array.isArray(item)){
           // 如果是数组 就扔回堆栈底部
           // 注意扔回底部的不再是 item这个数组了
           // 使用了 ... 之后 , 扔回去的就是一个 比 item少一维的数组 或者元素了
          stack.push(...item)
      }else{
          // 直到上面某个元素不是数组,将它 推给 converted 顶部
          converted.unshift(item)
      }
  }
  console.log(converted);
    })([1,2,[3,4,[5,6],7],8]);