【计算机基础】

线程、协程的状态

二. 线程的状态

• ①. 新建状态(NEW)
  新建(NEW)：新创建了一个线程对象。
  实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了新建状态。

• ②. 就绪状态(RUNNABLE/READY)
  可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU 的使用权 。

• ③. 运行中状态(RUNNING)
  运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码

• ④. 阻塞状态(BLOCKED)
  阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了CPU 使用权，也即让出了CPU时间片，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得CPU时间片转到运行(running)状态。阻塞的情况分三种：

  • 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
  • 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
  • 超时等待：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

• ⑤. 终止状态(TERMINATED)
  死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

从运行态的线程怎么变成阻塞态

计算机网络

https://blog.csdn.net/weixin_43746433/article/details/115839931

DNS解析

client 提出域名解析请求，并发送给本地域名服务器
本地域名解析服务器收到请求，先查询缓存（有缓存直接返回），若没有缓存，就去根域名服务器找
根域名服务器告诉本地域名服务器一个主域名服务器的地址
本地域名服务器又去找主域名服务器，若主域名服务器没有缓存，则告诉一个具体的解析服务器地址
本地域名服务器最后去找解析服务器地址，获取到解析结果

计算机基础

进程间通讯的7种方式

1、常见的通信方式

• 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
  命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

• 消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

• 共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。

• 信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

• 套接字Socket：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

• 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

讲一下程序的虚拟内存、常驻内存和逻辑内存。

虚拟内存（VIRT）：程序占用的内存大小。程序申请多少内存，就增长多少内存。
常驻内存（RES）：实际上当前占用的内存大小（部分未使用到的虚拟内存可能被写入磁盘上）
共享内存（SHR）：除了自身进程的共享内存，也包括其他进程的共享内存。虽然进程只使用了几个共享库的函数，但它包含了整个共享库的大小。计算某个进程所占的物理内存大小公式：RES – SHR。swap out后，它将会降下来

逻辑内存：虚拟内存所创建出来的展示给开发者的内存空间即为逻辑内存。虚拟地址即为逻辑地址。
物理内存：实际的硬盘的内存

虚拟内存和常驻内存的存在，需要引入页表，来记录哪些存在与内存中，哪些不存在。当进程访问的数据不在物理内存上的时候，需要缺页中断。将磁盘上面的数据读入内存。而这个过程是操作系统自动完成的，不需要开发人员感知。

堆和栈是存啥的？

• 堆：程序用来动态分配和释放的空间，一般可以达到4个G。
• 栈：由编译器自动分配释放，存放函数的参数值，局部变量的值等。

栈内存:栈内存首先是一片内存区域，存储的都是局部变量，凡是定义在方法中的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

堆内存: 存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，Java有垃圾回收机制不定时的收取。

• 堆自底向上生长，栈自顶向下生长。堆是动态分配的。栈可以是静态分配和动态分配两种，但是栈的动态分配由编译器释放。

堆栈中数据插入、删除遵循 后进先出的规则，因此插入数据向上增长和向下增长需要注意插入的方向。

堆是一个二叉树，以最大堆为例，建堆的本质是让这颗二叉树满足父节点的值大于等于子节点节点。
自底向上本质上就是一个倒序的层次遍历，每个层上的元素与自己的孩子比较一下，保证自己大于子节点，最后堆顶一定是最大值。通过层层向上的方式，符合堆性质的区域从底层向上扩张，最终建堆完成。
如果是自顶向下，当第i层和他的孩子i+1层比较中出现交换，交换后的i层不能保证小于i-1层，于是又要向上验证，最坏情况是验证到顶。正常建堆的时间复杂度是log2n，自顶向下这么一搞，相当于二叉树上每条路径要做一个冒泡排序，复杂度还不得上天（懒得算）。当然要自底向上

什么是大小端?

对于一个由2个字节组成的16位整数，在内存中存储这两个字节有两种方法：

一种是将低序字节存储在起始地址，这称为小端(little-endian)字节序；

另一种方法是将高序字节存储在起始地址，这称为大端(big-endian)字节序。

总结：

表示数据在存储器中的存放顺序

• 小端模式：数据的高字节，存放在高地址中。计算机读取数据的方向，是从高地址开始读取的；
• 大端模式：数据的高字节，存放在低地址中。计算机读取数据的方向，是从低地址开始读取的；

记忆口诀：“小端低低”
iOS都是小端模式。

三、为什么有大小端模式之分呢？
由于各硬件商，按自己的构想设计硬件，导致了硬件设计不同，工作原理也有差异。所以有的硬件采用了大端模式，有的硬件采用了小端模式。都认为各自采用的模式是更优秀；

什么是死锁？什么情况下会发生（避免）死锁？

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。

死锁产生的4个必要条件？

• 互斥条件：互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
• 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
• 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
• 环路等待条件：指在发生死锁时，必然存在一个进程有资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

解决死锁的基本方法

理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。只要打破四个必要条件之一就能有效预防死锁的发生：

• 打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。
• 打破不可抢占条件：当一进程占有一独占性资源后又申请一独占性资源而无法满足，则退出原占有的资源。
• 打破占有且申请条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待，这样就不会占有且申请。（golang1.14抢占式调度）
• 打破循环等待条件：实现资源有序分配策略，对所有设备实现分类编号，所有进程只能采用按序号递增的形式申请资源。

顺序获得锁（golang 互斥锁正常、饥饿模式）

当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。
如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生

超时放弃

另外一个可以避免死锁的方法是在尝试获取锁的时候加一个超时时间，这也就意味着在尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求。

若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。这段随机的等待时间让其它线程有机会尝试获取相同的这些锁，并且让该应用在没有获得锁的时候可以继续运行(译者注：加锁超时后可以先继续运行干点其它事情，再回头来重复之前加锁的逻辑)。

死锁检测

死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。

每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。

当一个线程请求锁失败时，这个线程可以遍历锁的关系图看看是否有死锁发生。例如，线程A请求锁7，但是锁7这个时候被线程B持有，这时线程A就可以检查一下线程B是否已经请求了线程A当前所持有的锁。如果线程B确实有这样的请求，那么就是发生了死锁（线程A拥有锁1，请求锁7；线程B拥有锁7，请求锁1）。

常见的死锁

MySQL死锁

golang1.14抢占式调度

基于协作的抢占式调度，1.13版本 go依赖调用函数栈增长检测代码的方式
比如一个goroutine运行了很久，但是它并没有调用另一个函数，则它不会被抢占
空的for循环没有调用函数，这种调度方式下会阻塞，

Go 1.14 版本之前，没有实现抢占式调度，必须某个 goroutine 交出控制权，因此自旋锁会导致死锁。如下图：A等待B释放锁，但是执行了GC，然后B被挂起，runtime需要等待A挂起，但是A在执行自旋锁，就发生了死锁。需要在自旋锁内部调用一次 runtime.GoSched 来交出 CPU 控制权

线程在切换过程中干了啥？

进程调度，切换进程上下文，包括分配的内存，包括数据段，附加段，堆栈段，代码段，以及一些表格。
线程调度，切换线程上下文，主要切换堆栈，以及各寄存器，因为同一个进程里的线程除了堆栈不同，其余基本上共享。
协程又称为轻量级线程，每个协程都自带了一个栈，可以认为一个协程就是一个函数和这个存放这个函数运行时数据的栈，这个栈非常小，一般只有几十kb。

进程切换分两步：
1.切换页目录以使用新的地址空间
2.切换内核栈和硬件上下文
对于linux来说，线程和进程的最大区别就在于地址空间，对于线程切换，第1步是不需要做的，第2是进程和线程切换都要做的。

切换的性能消耗：
1、线程上下文切换和进程上下问切换一个最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下文切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。
2、另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说，一旦去切换上下文，处理器中所有已经缓存的内存地址一瞬间都作废了。还有一个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲（processor’s Translation Lookaside Buffer (TLB)）或者相当的神马东西会被全部刷新，这将导致内存的访问在一段时间内相当的低效。但是在线程的切换中，不会出现这个问题