虚拟机（Virtual Machine）就是允许我们在当前操作系统中运行其他操作系统的软件，本质上和 VS、QQ 这些应用程序一样。


所以，只要我们在电脑（PC 或笔记本等）上安装好虚拟机软件，就可以模拟出来若干台相互独立的虚拟 PC 设备，每一个都如何一台真实的计算机。在此基础上，我们可以给每台虚拟的 PC 设备安装指定的操作系统，这样就可以实现在一台电脑上同时运行多个操作系统。


另外，还可以将这些虚拟的系统连成局域网，用来部署网站集群架构等更深层次的运维技术，这样的虚拟技术，有兴趣的读者可以搜索“集群”做详细了解。




图 1 Windows 10系统安装WMware Workstation虚拟软件窗口



如图 1 所示，展示的是在 Windows 10 桌面操作系统上安装的虚拟机软件 VMware Workstation（简称 VMware），这里通过配置 VMware 虚拟出了 2 台 PC 设备，且分别在这 2 台 PC 上安装了 Linux 系统（CentOS 发行版）和 Windows 系统。这 2 个虚拟机同时在一台电脑上独立运行，几乎互不干扰，并且可以同在一个局域网内，还可以互相通信。


经过前面对虚拟机软件的介绍，相信读者应该知道了虚拟机软件到底是什么了吧。下面，笔者介绍一些网友常用的虚拟机软件，如表 1 所示。

 

表 1 常用的虚拟机软件及选择建议
	
虚拟机软件
			
特点及选择建议
		
VM（VMware Workstation）
			
工作站版虚拟化软件，简单、易用，适合用于搭建学习环境。
		
KVM/Xen Linux 的虚拟化
			
服务器级虚拟化软件，适合企业虚拟化应用，不适合用于搭建学习环境。
		
Virtual PC
			
MAC 平台可以用
		
VirtualBox 
			
开源的虚拟机软件
		

目录
文章目录
目录
前文列表
KVM
KVM 的功能列表
KVM 工具集
KVM 虚拟机的本质是什么
vCPU 的调度与性能问题
Nova 支持的 vCPU 绑定
vcpu\_pin\_set 配置项
CPU 绑定策略

前文列表
OpenStack Nova 高性能虚拟机之 NUMA 架构亲和

多进程、多线程与多处理器计算平台的性能问题
KVM
KVM（Kernel-based Virtual Machine 基于内核的虚拟机）是可嵌入 Linux Kernel 的内核功能模块，与 QEMU、Libvirt 等用户态应用程序协同组成一套完整的 Linux 全虚拟化解决方案。
由 KVM 提供 CPU 和内核虚拟化，并通过 /dev/kvm 设备暴露出创建 vCPU、分配虚拟内存地址空间、读写 vCPU 寄存器等 Hypervisor 功能调用接口。但只有 vCPU 和虚拟内存不足以构成虚拟机，还需要依赖于由 QEMU 模拟出来的各类 I/O 设备共同组成。KVM 提供的核心虚拟化能力弥补了原生 QEMU 需要通过模拟 CPU 来进行指令翻译所产生的性能损耗。在较新的 QEMU 发行版（1.3 及以上）中，已经合并了 KVM 的适配代码实现，在执行 qemu 指令时通过选项 --enable-kvm 即可启用。

简单来说，KVM 运行在内核态，负责 CPU 和内存的虚拟化。QEMU 运行在用户态，负责模拟和管理各类虚拟硬件设备。QEMU 通过 ioctl() 调用 /dev/kvm 接口，将 CPU 指令翻译的部分交由 KVM 完成。

为了追求更好的虚拟机性能，后续还为该方案追加了一些具有直通（Pass-through）特性的半虚拟化设备和驱动程序（e.g. virtio_blk、virtio_net ），用于替代 QEMU 对一些关键设备（e.g. 磁盘、网卡）的模拟，进一步提升了性能，用户可以根据实际需要来选择是否启用。

除了上述的 QEMU + KVM 虚拟化实现之外，还需要为用户提供友好的操作入口才能算是一套完整的解决方案。Libvirt 就充当着这个入口，为用户提供 GUI、CLI、API 等工具集。

为了方便描述，在下文中，我们将这一套 Linux 全虚拟化解决方案，简称为 KVM。
KVM 的功能列表

支持 SMP 体系结构亲和
支持 NUMA 体系结构亲和
支持 CPU 亲和性
支持 CPU 和内存超分（Overcommit）
支持 PCI 直通设备和 SR-IOV
支持半虚拟化 I/O 设备和驱动（VirtIO）
支持热插拔 CPU，DISK，NIC 等虚拟硬件设备
支持热迁移（Live Migration）
支持内核内存共享技术（KSM，Kernel Shared Memory）

KVM 工具集

virsh：命令行工具（CLI）
virt-manager：图形界面工具（GUI）
virt-viewer：虚拟机远程桌面连接工具
virt-v2v：虚拟机迁移工具
virt-install：虚拟机创建命令行工具
virt-clone：虚拟机克隆工具
virt-top：虚拟机性能监控工具
sVirt：虚拟机安全工具

KVM 虚拟机的本质是什么
KVM 虚拟机，常用 Guest 表述，由 vCPU、虚拟内存、虚拟 I/O 设备以及 GuestOS 组成：

Guest 的本质是一个 QEMU 进程
Guest 的一个 vCPU 就是一个 QEMU 进程内的线程
Guest 的虚拟内存就是分配给 QEMU 进程的内存地址空间的一部分
GuestOS 可以继承 HostOS 内核中的 NUMA 和 大页内存特性

vCPU、QEMU 进程、物理 CPU 及系统调度器之间的逻辑关系：

而 GuestOS 的物理表现实际上就是一个 XML 文件，描述了 GuestOS 的特征信息。
vCPU 的调度与性能问题

注：上图为 vSphere 的 vCPU 调度示意图，与 KVM 大同小异，可以用作参考。
既然 HostOS 将 vCPU 当普通线程来进行调度，那么 vCPU 的调度与性能问题实际上就是 Linux 线程在多处理器计算平台中的调度与性能问题。关于这个问题我们曾经在《多进程、多线程与多处理器计算平台的性能问题》一文中讨论过，这里不再赘述。简单来说，提高虚拟机 vCPU 的性能，需要贯彻三点原则：

减少多线程上下文切换的性能损耗
减少用户线程模式切换的性能损耗
提高高速缓存的命中率

而实现这些原则的手段大致上有两种：

规划出给 Guest 专用的 pCPU s，并且 vCPUs 和 pCPUs 所拥有的 Cores 数量相近
将 vCPU 绑定到指定的 pCPU 上运行

KVM 本身就支持 CPU 绑定的相关功能，使用非常简单：
root@devstack:~# virsh help
 ...
    vcpucount                      domain vcpu counts
    vcpuinfo                       detailed domain vcpu information
    vcpupin                        control or query domain vcpu affinity
 
# 将 guest 21 的第 0 个 vCPU 绑定到 pCPU 1 上
root@devstack:~# virsh vcpupin 21 0 1

Nova 支持的 vCPU 绑定
vcpu_pin_set 配置项
vcpu_pin_set 是 compute node 上的 nova.conf 配置项，是 OpenStack 最早设计用于限定 Guest 可以使用 compute node 上的 pCPUs 的范围，解决了下述问题：

currently the instances can use all of the pcpu of compute node, the host may become slowly when vcpus of instances are busy, so we need to pin vcpus to the specific pcpus of host instead of all pcpus. the vcpu xml conf of libvirt will change to like this:  <vcpu cpuset="4-12,^8,15">1</vcpu>

简单来说，就是为了让用户一方面可以划分出 Guest 专用的 pCPUs 以保证性能，另一方面也是为了防止 Guest 过分争抢 Host 进程的 CPU 资源，为 Host 适当的留下一些 CPU 以保证正常运作。
NOTE：如果指定的 CPU 范围超出了宿主机原有的 CPU 范围则会触发异常。
CPU 绑定策略
CPU 绑定策略机制经常会结合 NUMA topology 一起使用，在《OpenStack Nova 高性能虚拟机之 NUMA 架构亲和》一文中我们已经介绍过，这里也不再赘述。
openstack flavor set FLAVOR-NAME \
    --property hw:cpu_policy=CPU-POLICY \
    --property hw:cpu_thread_policy=CPU-THREAD-POLICY



CPU-POLICY：

shared (default)：不独占 pCPU 策略，允许 vCPUs 在不同的 pCPUs 间浮动，尽管 vCPUs 受到 NUMA node 的限制也是如此。
dedicated：独占 pCPU 策略，Guest 的 vCPUs 将会严格的 pinned 到 pCPUs 的集合中。在没有明确配置 Guest NUMA Topology 的情况下，Nova 会将每个 vCPU 都作为一个 Socket 中的一个 Core；如果已经明确的配置了 Guest NUMA Topology 的话，那么虚拟机就会严格按照 Guest NUMA Topology 和 Host NUMA Topology 的映射关系将 vCPUs pinned to pCPUs，pCPUs 可能是一个 Core 或是一个 Thread，根据 Host 实际的处理器体系结构以及 CPU-THREAD-POLICY 来共同决定。此时的 CPU overcommit ratio 为 1.0（不支持 CPU 超配），避免 vCPU 的数量大于 Core 的数量导致的线程上下文切换损耗。



CPU-THREAD-POLICY：

prefer (default)：如果 Host 开启了超线程，则 vCPU 优先选择在 Siblings Thread 中运行，即所有的 vCPU 都只会考虑 siblings。例如：4 个逻辑核属于同一 NUMA，其中 CPU1 和 CPU2 属于相同物理核，CPU3 和 CPU4 属于不同的物理核，若此时创建一个 Flavor vCPU 为 4 的云主机会创建失败，因为 siblings 只有 [set([1, 2])]；否则，vCPU 优先选择在 Core 上运行。
isolate（vCPU 性能最好）：vCPU 必须绑定到 Core 上。如果 Host 没有开启超线程，则理所当然会将 vCPU 绑定到 Core 上；相反，如果 Host 开启了超线程，则 vCPU 会被绑定到  Siblings Thread 的一个 Thread 中，并且其他的 vCPU 不会再被分配到该 Core 上，相当于 vCPU 独占一个 Core，避免 Siblings Thread 竞争。
require（vCPU 数量最多）：vCPU 必须绑定到 Thread 上。Host 必须开启超线程，每个 vCPU 都会被绑定到 Thread 上，直到 Thread 用完为止。如果没有开启的话，那么该 Host 不会出现在 Nova Scheduler 的调度名单中。



NOTE 1：只有设定 hw:cpu_policy=dedicated 时，hw:cpu_thread_policy 才会生效。后者设定的是 vCPU pinning to pCPU 的策略。
NOTE 2：如果 pinned（isolate） 和 unpinned 的虚拟机运行在同一个 compute node，则会发生 CPU 竞争，因为 unpinned 的虚拟机不会考虑到 pinned 虚拟机的资源需求，由于 Cache 的影响，这将会严重的影响进行了 CPU 绑定的虚拟机的性能，尤其当两者同处一个 NUMA 节点时。所以，应该使用 Host Aggregate 来区分开 pinned 和 unpinned 的虚拟机，退一步来说，最起码也应该让两者运行在不同的 NUMA 节点上。而且如果一个 compute node 上运行的全是 pinned 虚拟机，那么这个 compute node 不建议配置超配比。
NOTE 3：如果 cpu_thread_policy=prefer | require 时，Nova 的 Thread 分配策略是尽量先占满一个 Core，然后再使用下一个 Core 上的 Thread，尽量避免 Thread/Core 碎片影响到后面创建的虚拟机。

最近阅读新版的《深入理解Java虚拟机》有了自己实现一个虚拟机的想法，在完成阶段性的目标后重新认识了一下JVM，希望记录并且分享。本文主要为了总结Java虚拟机是什么，本文并不会介绍内存，GC，类加载器这些面试类的“知识要点”，而是期望总结清楚最本质的东西。
可执行文件与Class文件
我们先来看一段汇编代码
Hello, OS world!程序：
    org 07c00h
    mov ax, cs
    mov ds, ax
    mov es, ax
    call DispStr
    jmp $
DispStr:
    mov ax, BootMessage
    mov bp, ax
    mov cx, 16
    mov ax, 01301h
    mov bx, 000ch
    mov dl, 0
    int 10h
    ret
BootMessage:    db  "Hello, OS world!"
times   510-($-$$)  db  0
dw  0xaa55

这段代码是在用于计算机的引导扇区中的，我们将它编译后保存在硬盘的引导扇区上让后设置BIOS从该硬盘启动，就会执行这段代码，在显示器上输出一个“Hello, OS world!”。
我们知道计算机在开机的时候会先执行BIOS的代码，这部分代码是由主板的厂商提供的预先保存在主板的ROM中，然后跳转到引导设备的07c00h地址开始执行指令，所以上述代码中我们使用org指令从07c00h开始分配存储空间，即mov ax, cs这个指令被保存在07c00h地址上。

这样我们就看到了最本质的程序，一段程序直接运行在物理主机上，没有Windows或者Linux这样的操作系统。
现在我们回到Class文件上
我们用javap来看一段Hello world程序编译后class的结构

“javap -verbose Test”
Classfile /Users/dim/IdeaProjects/untitled/target/classes/Test.class
  Last modified 2020年4月18日; size 515 bytes
  MD5 checksum ad0d0d889ae47100c8b9bdd620fb0948
  Compiled from "Test.java"
public class Test
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #5                          // Test
  super_class: #6                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // Hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // Test
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               LTest;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               Test.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               Hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               Test
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public Test();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 3: 0
        line 4: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "Test.java"

当我们运行启动JVM的时候指定执行某个class或者Jar包，虚拟机就会从指定class的Main方法开始执行“java Test”
这个过程就好比我们将一个写有“Hello, OS world!”程序的设备安装到了物理机器上从BIOS指定从这个设备进行引导。在JVM启动时可以通过Jar包的META-INF目录读取配置的代码入口，也可以在启动JVM时直接指定。
事实上他们都是以同一种方式开始一段程序的执行，找到07c00h地址对应的指令或者Main方法的第一条指令，至于为什么是07c00h和Main方法，这更多是一种规范，技术上你可以开发一个新的BIOS程序或者JVM从你喜欢的地方开始执行。
有的人可能会觉得一段C代码的入口也是main函数为什么JVM不是类比一个操作系统呢？首先C代码中的main入口是提供给操作系统调用的，因为操作系统的本质是一个硬件的管理功能，JVM中的一些功能是类似于操作系统的功能，比如GC，但是本文不对这些功能做讲解是为了更好的体现JVM的本质（实际上，在阅读JVM规范的时候你会发现文档中很少有提及这些类似于操作系统的功能，像垃圾回收这些相关的文档可能需要去阅读各虚拟机的具体实现的文档如HotSpot，因为它们不是必须的）
CPU结构与JVM结构


这是我在网络上找的一个图片8086CPU的内部结构，我们试着解释一段汇编的代码
    mov ax, cs //将寄存器cs的值传送到ax
    mov ds, ax//将寄存器ax的值传送到ds
    mov es, ax//将寄存器ax的值传送到es
    call DispStr//调用DispStr

其实这些CPU的指令都是做着这些非常基本的工作，移动某个寄存器的数据到另一个地方，从某个设备读取数据



我先不去管本文中不关心的部分

主要来看一下程序计数器和虚拟机栈（堆内存更像是一台计算机的主存）

我们知道程序计数器是一个线程私有的区域它主要用于表示当前执行到哪条指令，类似的功能在8086CPU上可以通过段地址寄存器加上IP寄存器或者某个偏移量



图中的部分最终输出的20地址就是JVM中程序计数器的工作

再来看虚拟机栈的内容



每次JAVA的方法调用都会产生一个栈针（实际上栈针的概念类似与CPU相应中断的时候保存上下文执行完中断后再返回的步骤），栈针不仅包含图中的信息但是我们目前关系的仅仅是操作数栈，JVM的指令基本都是通过操作数栈实现的，这里和CPU的结构有点不太一样，其实只是两种设计而已，他们实现相同的功能。
比如在CPU中我们可以用ADD指令进行加法运算
	add ax,bx//将ax寄存器的值加上bx寄存器的值在赋值给ax

而对应的在JVM中我们可以做类似的加法运算
	iadd //从操作数栈中弹出两个int值相加后压入操作数栈

JVM的执行引擎类似与运算器和寄存器，但是他们采用了不同的实现。
总结
JVM的本质其实是一个可以更具特定指令进行特定数据操作的程序，它使用软件模拟实现CPU中逻辑电路实现的基本指令功能，Java语言通过编译器将代码编译成这些最基本的二进制指令来告诉这个程序如何操作特定内存模型中的数据，通过对基本指令的组合实现一个较为复杂的方法，再通过对较为复杂方法的组合实现一个特定功能，业务就是这样被实现的。

目录：（你将学习以下内容）
1.虚拟机是什么？
2.虚拟机的功能
3.虚拟机的应用
4.虚拟机的种类：
（1）VMware虚拟机

（2）VirtualBox虚拟机

1.虚拟机是什么？
虚拟机的本质：虚拟机在本质上就是一个应用程序软件。像在windows上运行的其他应用软件一样，只是他的作用功能不一样罢了。
2.虚拟机的功能
虚拟机（Virtual Machine）指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机。也就是可以使你的计算机同时具有多种系统，不管是其他的windows系统，还是Linux系统，还是Mac OS 系统都可以。
3.虚拟机的应用
（1）使一台计算机同时具有多个操作系统。
很多人只知道计算机具有windows系统，却不知道还有Linux系统，Mac OS系统，然而作为好奇心很强的我，当然要体验一下操作其他系统感觉，难道我们需要再另行购买一台Mac 苹果电脑？难道我们还要另行安装一下Linux系统？不！不需要，借助虚拟机软件，我们就可以享受各种操作系统的乐趣啦。
（2）可以放心的测试病毒，而不会威胁到你的真实机。
我们都害怕病毒，轻则黑屏蓝屏，重则死机，当我们开发一个病毒，或者对下载的东西不放心的时候，就可以在虚拟机里测试，即使中毒啦，也对你的计算机没有什么危害，只要在虚拟机再安装一个系统就可以啦。
（3）可以测试自己编写的程序，也相当于在另一台计算机运行了。
有时候，我们开发了一个小软件，也想发给朋友试试，却发现朋友用不了，明明在自己的计算机运行的好好的，那么我们自然想在发给朋友的前，先找另一台计算机测试测试，虚拟机就可以提供给你另一台计算机。
（4）可以搭建一个符合自己需求的操作系统的环境
在学Python的时候，总觉得环境搭建很复杂，要么是自己本机计算机安装的软件太多，有些软件还相互抑制，导致环境的搭建很容易出错，那么你完全可以在虚拟机搭建一个专用的环境，不用安装那么软件。
4.虚拟机的种类：
下面之讲两只种主流的虚拟机，分别是VMware虚拟机和VirtualBox虚拟机，在本章节中只是粗略的介绍，后续章节会展开详细的介绍。
（1）VMware虚拟机
1)关于VMware虚拟机：
a.桌面图标：


b.软件首页：

2）VMware下载官网：
https://www.vmware.com/cn/products/workstation-pro/workstation-pro-evaluation.html

（注：需要激活，激活的序列号可网上搜寻的来。）
（2）VirtualBox虚拟机
1)关于VirtualBox虚拟机：（开源免费的）
a.桌面图标：

b.软件首页：

2）VirtualBox下载官网：
https://www.virtualbox.org/


我是张一根，一个在读本科的计算机爱好者，期盼和你一起交流计算机的知识，让我们在这个大时代里一起进步。