第 4 章 程序计数器 (PC寄存器)
1、PC寄存器概述 (重点)

文档网址

https://docs.oracle.com/javase/specs/jvms/se8/html/index.html



PC寄存器介绍 以及 作用 :

线程私有, 运行速度最快的存储区域, 程序计数器会存储当前线程正在执行的Java方法的JVM指令地址
PC寄存器不会出现OOM(OutofMemoryError) 内存溢出, StackOverFlow 栈溢出 的情况
字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令
当CPU并发执行, cpu时间片轮训执行不同的线程(或者发生中断操作), 使用pc寄存器中存储的指令地址, 来 恢复到原来的执行位置



JVM中的程序计数寄存器（Program Counter Register）中，Register的命名源于CPU的寄存器，寄存器存储指令相关的现场信息。CPU只有把数据装载到寄存器才能够运行。
这里，并非是广义上所指的物理寄存器，或许将其翻译为PC计数器（或指令计数器）会更加贴切（也称为程序钩子），并且也不容易引起一些不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。
它是一块很小的内存空间，几乎可以忽略不记。也是运行速度最快的存储区域。
在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法 (虚拟机栈的栈顶栈帧)。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址 ,或者，如果是在执行native方法，则是未指定值（undefned）。
它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
它是唯一一个在Java虚拟机规范中没有规定任何OutofMemoryError情况的区域。



PC 寄存器的作用


PC寄存器用来存储指向下一条指令的地址，也即将要执行的指令代码。由执行引擎将指令解释为机器码交由cpu进行处理


2、代码示例

代码

public class PCRegisterTest {

    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = i + j;

        String s = "abc";
        System.out.println(i);
        System.out.println(k);

    }
}


反编译：javap -v xxx.class

// 常量池
Constant pool:
   #1 = Methodref          #6.#26         // java/lang/Object."<init>":()V
   #2 = String             #27            // abc
   #3 = Fieldref           #28.#29        // java/lang/System.out:Ljava/io/PrintStream;
   #4 = Methodref          #30.#31        // java/io/PrintStream.println:(I)V
   #5 = Class              #32            // com/atguigu/java/PCRegisterTest
   #6 = Class              #33            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/atguigu/java/PCRegisterTest;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               i
  #19 = Utf8               I
  #20 = Utf8               j
  #21 = Utf8               k
  #22 = Utf8               s
  #23 = Utf8               Ljava/lang/String;
  #24 = Utf8               SourceFile
  #25 = Utf8               PCRegisterTest.java
  #26 = NameAndType        #7:#8          // "<init>":()V
  #27 = Utf8               abc
  #28 = Class              #34            // java/lang/System
  #29 = NameAndType        #35:#36        // out:Ljava/io/PrintStream;
  #30 = Class              #37            // java/io/PrintStream
  #31 = NameAndType        #38:#39        // println:(I)V
  #32 = Utf8               com/atguigu/java/PCRegisterTest
  #33 = Utf8               java/lang/Object
  #34 = Utf8               java/lang/System
  #35 = Utf8               out
  #36 = Utf8               Ljava/io/PrintStream;
  #37 = Utf8               java/io/PrintStream
  #38 = Utf8               println
  #39 = Utf8               (I)V
{
  public com.atguigu.java.PCRegisterTest();
    descriptor: ()V
    flags: 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 7: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/atguigu/java/PCRegisterTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: bipush        10
         2: istore_1
         3: bipush        20
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: ldc           #2                  // String abc
        12: astore        4
        14: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        17: iload_1
        18: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
        21: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        24: iload_3
        25: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
        28: return
      LineNumberTable:
        line 10: 0
        line 11: 3
        line 12: 6
        line 14: 10
        line 15: 14
        line 16: 21
        line 18: 28
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      29     0  args   [Ljava/lang/String;
            3      26     1     i   I
            6      23     2     j   I
           10      19     3     k   I
           14      15     4     s   Ljava/lang/String;


左边的数字代表指令地址（指令偏移），即 PC寄存器中可能存储的值，然后执行引擎读取 PC 寄存器中的值，并执行该指令


3、两个面试题 (重要)


使用PC寄存器存储字节码指令地址有什么用呢？
为什么使用 PC 寄存器来记录当前线程的执行地址呢？



因为线程是一个个的顺序执行流，CPU需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪开始继续执行
JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令




PC寄存器为什么被设定为私有的？

总结下面: 为了保证当并发执行的多个线程的时候, cpu时间片疯狂切换, 当切换到别的线程的时候, 我们要记录上一个线程执行到哪个指令了. 所以使用pc寄存器来存储; 如果设置为线程共享的pc寄存器, 当切换到上一个线程的时候, 它恢复到原来执行的位置. 就不准确了



我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法(并发操作)，CPU会不停地做任务切换，这样必然导致经常中断或恢复，如何保证分毫无差呢？
为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分配一个PC寄存器，这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。
由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器中的一个内核，只会执行某个线程中的一条指令。
这样必然导致经常中断或恢复，如何保证分毫无差呢？每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。

4、CPU 时间片

并发执行的时候: 宏观上来说, 同时执行; 微观上来说, 串行执行


CPU时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片。
在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。
在微观上：由于只有一个CPU(当有多核,多个CPU的时候, 真正意义上存在并行, 但也存在并发的现象.)，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

最近项目搬家，从Github搬到Gitee，所以大批项目需要修改仓库地址。至于为什么要从Github切换到Gitee，主要是因为Github有时确实太慢了，页面打不开，代码提交不上去。还有就是因为自己很多项目是私有的，总会出现两个网站来回切换。尽管Github是一个程序员的标配，但是在这种背景下，使用Gitee到也是不得已！
修改Git远程分支的方法有很多，这里只介绍几种
方法一：通过命令行修改远程地址
> cd json
> git remote set-url origin https://gitee.com/jouypub/json.git
方法二：先删除原有仓库地址，然后添加新地址
> cd json
> git remote rm origin
> git remote add origin https://gitee.com/jouypub/json.git
方法三：修改配置文件
> cd json/.git
> vim config
[core]
repositoryformatversion = 0
filemode = true
logallrefupdates = true
precomposeunicode = true
[remote "origin"]
# 修改成新的仓库地址
url = https://gitee.com/jouypub/json.git
fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
remote = origin
merge = refs/heads/master
欢迎订阅「K叔区块链」 - 专注于区块链技术学习
博客地址：http://www.jouypub.com
简书主页：https://www.jianshu.com/u/756c9c8ae984
segmentfault主页：https://segmentfault.com/blog/jouypub
腾讯云主页：https://cloud.tencent.com/developer/column/72548

什么是线程安全？
在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。
如何保证线程安全？
给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。
让线程也拥有资源，不用去共享进程中的资源。如： 使用threadlocal可以为每个线程的维护一个私有的本地变量。
什么是单例模式？
单例模式指在整个系统生命周期里，保证一个类只能产生一个实例，确保该类的唯一性。
单例模式分类
单例模式可以分为懒汉式和饿汉式，两者之间的区别在于创建实例的时间不同：
懒汉式：指系统运行中，实例并不存在，只有当需要使用该实例时，才会去创建并使用实例。（这种方式要考虑线程安全）
饿汉式：指系统一运行，就初始化创建实例，当需要时，直接调用即可。（本身就线程安全，没有多线程的问题）
单例类特点
构造函数和析构函数为private类型，目的禁止外部构造和析构
拷贝构造和赋值构造函数为private类型，目的是禁止外部拷贝和赋值，确保实例的唯一性
类里有个获取实例的静态函数，可以全局访问
01 普通懒汉式单例 （ 线程不安全 ）
///  普通懒汉式实现 -- 线程不安全 //
#include <iostream> // std::cout
#include <mutex>    // std::mutex
#include <pthread.h> // pthread_create

class SingleInstance
{

public:
    // 获取单例对象
    static SingleInstance *GetInstance();

    // 释放单例，进程退出时调用
    static void deleteInstance();
    
    // 打印单例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    SingleInstance();
    ~SingleInstance();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    SingleInstance(const SingleInstance &signal);
    const SingleInstance &operator=(const SingleInstance &signal);

private:
    // 唯一单例对象指针
    static SingleInstance *m_SingleInstance;
};

//初始化静态成员变量
SingleInstance *SingleInstance::m_SingleInstance = NULL;

SingleInstance* SingleInstance::GetInstance()
{

    if (m_SingleInstance == NULL)
    {
        m_SingleInstance = new (std::nothrow) SingleInstance;  // 没有加锁是线程不安全的，当线程并发时会创建多个实例
    }

    return m_SingleInstance;
}

void SingleInstance::deleteInstance()
{
    if (m_SingleInstance)
    {
        delete m_SingleInstance;
        m_SingleInstance = NULL;
    }
}

void SingleInstance::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

SingleInstance::SingleInstance()
{
    std::cout << "构造函数" << std::endl;
}

SingleInstance::~SingleInstance()
{
    std::cout << "析构函数" << std::endl;
}
///  普通懒汉式实现 -- 线程不安全  //

// 线程函数
void *PrintHello(void *threadid)
{
    // 主线程与子线程分离，两者相互不干涉，子线程结束同时子线程的资源自动回收
    pthread_detach(pthread_self());

    // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
    int tid = *((int *)threadid);

    std::cout << "Hi, 我是线程 ID:[" << tid << "]" << std::endl;

    // 打印实例地址
    SingleInstance::GetInstance()->Print();

    pthread_exit(NULL);
}

#define NUM_THREADS 5 // 线程个数

int main(void)
{
    pthread_t threads[NUM_THREADS] = {0};
    int indexes[NUM_THREADS] = {0}; // 用数组来保存i的值

    int ret = 0;
    int i = 0;

    std::cout << "main() : 开始 ... " << std::endl;

    for (i = 0; i < NUM_THREADS; i++)
    {
        std::cout << "main() : 创建线程:[" << i << "]" << std::endl;
        
        indexes[i] = i; //先保存i的值
        
        // 传入的时候必须强制转换为void* 类型，即无类型指针
        ret = pthread_create(&threads[i], NULL, PrintHello, (void *)&(indexes[i]));
        if (ret)
        {
            std::cout << "Error:无法创建线程," << ret << std::endl;
            exit(-1);
        }
    }

    // 手动释放单实例的资源
    SingleInstance::deleteInstance();
    std::cout << "main() : 结束! " << std::endl;
    
    return 0;
}
普通懒汉式单例运行结果：
从运行结果可知，单例构造函数创建了两个，内存地址分别为0x7f3c980008c0和0x7f3c900008c0，所以普通懒汉式单例只适合单进程不适合多线程，因为是线程不安全的。
普通懒汉式
02 加锁的懒汉式单例 （ 线程安全 ）
///  加锁的懒汉式实现  //
class SingleInstance
{

public:
    // 获取单实例对象
    static SingleInstance *&GetInstance();

    //释放单实例，进程退出时调用
    static void deleteInstance();
    
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    SingleInstance();
    ~SingleInstance();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    SingleInstance(const SingleInstance &signal);
    const SingleInstance &operator=(const SingleInstance &signal);

private:
    // 唯一单实例对象指针
    static SingleInstance *m_SingleInstance;
    static std::mutex m_Mutex;
};

//初始化静态成员变量
SingleInstance *SingleInstance::m_SingleInstance = NULL;
std::mutex SingleInstance::m_Mutex;

SingleInstance *&SingleInstance::GetInstance()
{

    //  这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
    //  避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
    if (m_SingleInstance == NULL) 
    {
        std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
        if (m_SingleInstance == NULL)
        {
            m_SingleInstance = new (std::nothrow) SingleInstance;
        }
    }

    return m_SingleInstance;
}

void SingleInstance::deleteInstance()
{
    std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
    if (m_SingleInstance)
    {
        delete m_SingleInstance;
        m_SingleInstance = NULL;
    }
}

void SingleInstance::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

SingleInstance::SingleInstance()
{
    std::cout << "构造函数" << std::endl;
}

SingleInstance::~SingleInstance()
{
    std::cout << "析构函数" << std::endl;
}
///  加锁的懒汉式实现  //
加锁的懒汉式单例的运行结果：
从运行结果可知，只创建了一个实例，内存地址是0x7f28b00008c0，所以加了互斥锁的普通懒汉式是线程安全的
加锁
03 内部静态变量的懒汉单例（C++11 线程安全）
///  内部静态变量的懒汉实现  //
class Single
{

public:
    // 获取单实例对象
    static Single &GetInstance();
    
    // 打印实例地址
    void Print();

private:
    // 禁止外部构造
    Single();

    // 禁止外部析构
    ~Single();

    // 禁止外部复制构造
    Single(const Single &signal);

    // 禁止外部赋值操作
    const Single &operator=(const Single &signal);
};

Single &Single::GetInstance()
{
    // 局部静态特性的方式实现单实例
    static Single signal;
    return signal;
}

void Single::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Single::Single()
{
    std::cout << "构造函数" << std::endl;
}

Single::~Single()
{
    std::cout << "析构函数" << std::endl;
}
///  内部静态变量的懒汉实现  //
内部静态变量的懒汉单例的运行结果：
-std=c++0x编译是使用了C++11的特性，在C++11内部静态变量的方式里是线程安全的，只创建了一次实例，内存地址是0x6016e8，这个方式非常推荐，实现的代码最少！
[root@lincoding singleInstall]#g++  SingleInstance.cpp -o SingleInstance -lpthread -std=c++0x
局部静态
04 饿汉式单例 （本身就线程安全）
// 饿汉实现 /
class Singleton
{
public:
    // 获取单实例
    static Singleton* GetInstance();

    // 释放单实例，进程退出时调用
    static void deleteInstance();
    
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    Singleton();
    ~Singleton();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    Singleton(const Singleton &signal);
    const Singleton &operator=(const Singleton &signal);

private:
    // 唯一单实例对象指针
    static Singleton *g_pSingleton;
};

// 代码一运行就初始化创建实例 ，本身就线程安全
Singleton* Singleton::g_pSingleton = new (std::nothrow) Singleton;

Singleton* Singleton::GetInstance()
{
    return g_pSingleton;
}

void Singleton::deleteInstance()
{
    if (g_pSingleton)
    {
        delete g_pSingleton;
        g_pSingleton = NULL;
    }
}

void Singleton::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Singleton::Singleton()
{
    std::cout << "构造函数" << std::endl;
}

Singleton::~Singleton()
{
    std::cout << "析构函数" << std::endl;
}
// 饿汉实现 /
饿汉式单例的运行结果：
从运行结果可知，饿汉式在程序一开始就构造函数初始化了，所以本身就线程安全的
饿汉式
特点与选择
懒汉式是以时间换空间，适应于访问量较小时；推荐使用内部静态变量的懒汉单例，代码量少
饿汉式是以空间换时间，适应于访问量较大时，或者线程比较多的的情况
需要C/C++ Linux服务器架构师学习资料加群获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

上篇文章讲了路由器寻路过程，今天说说“NAT映射”和“打洞机制”。
一，NAT映射
参考文章：https://www.cnblogs.com/penghuwan/p/7753022.html
要描述NAT， 要先讲讲私有地址和全局地址。我们说现在要从主机A给主机B发送消息，需要依赖的是主机A和主机B的端口号与IP地址。但是我们平常在电脑上
我们ipconfig出来都是私有IP地址，为什么会出现私有IP呢？就是因为IP地址不够用了，给你一台PC就分配一个公有IP地址太浪费了，而私有IP是不能直接在网络上进行通信的，你可以把私有IP看做是门牌号，假设你的门牌号是11号，但是北京有11号，上海也有11号，所以如果你直接说你是11号，快递员怎么可能知道你到底在呢！所以我们如果想在网络上进行通信，是需要将私有IP转为公网IP，那么谁来做这个工作呢？NAT映射表
NAT映射表存在在路由器里面，实现的是私有IP与公有IP之间的转换；实际上可能是你家一台路由器拥有一个公网IP，而所有连在这台路由器上的所有设备都共享一个公网IP。那么问题又来了，既然共享一个公网IP，那接受回来的数据又怎么知道到底应该是哪一台设备接受呢?我们说过了在网络上唯一表示一个进程需要的是IP地址+端口号，既然IP地址一样，我们就对端口号做文章就可以了，就如下图（同理我们也可以对A1，A2，A3进行拓展，这样IP地址就够用了）


二，打洞机制
比如说我用QQ给妈妈发个消息，实际上并不是我的主机和妈妈的主机直接通讯，我们之间要通过腾讯的服务器来帮助我们通讯，我的主机并不知道妈妈主机的IP以及端口号，妈妈主机也不知道我的。但是假如说我和妈妈现在要进行视频通话，如果中间再隔个腾讯服务器，就很难达到即时通讯的目标，所以腾讯借助公网IP就会帮我的主机和妈妈的主机打个洞来提高提高数据传输的效率。
有个问题是为什么是腾讯帮助打洞？这是因为路由器的保护机制：对于陌生IP第一次发送过来的数据包，路由器会进行屏蔽或丢弃，这是为了防止网络的恶意攻击。
打洞机制我认为可以这样：没有打洞机制前，就相当于腾讯是接线员，它知道我的电话也知道妈妈的电话，我和妈妈之间通讯需要打电话先给接线员，再有接线员转接才可以；但是打洞机制就相当于接线员把我的电话和妈妈的电话发给彼此，这样我们就可以直接联络了。