插曲——递归函数
这个问题困扰了我半天 觉都没睡好

先上 代码 思想我整理一下 再描述
#include <stdio.h>
void co(int a)
{
    a++;
    if(a<4)
    {
        co(a);
        co(a);

    }
    printf("%d\n",a);
}
int main(int argc, char*argv[])
{
    int a = 0;
    co(a);
    return 0;
}

输出结果：4 4 3 4 4 3 2 4 4 3 4 4 3 2 1

明确函数的双重用途
在很多情况下当我们调用一个函数时，需要new来调用而不用new来调用的话会出现很多问题，比如this指向问题等等。而在以前的语法当中我们无法判断其调用时是否使用new来调用，一般情况下我们通常用if判断它原型链上的指向是否有自身来判断，不但有些麻烦而且还并不是特别完善。
所以ES6提供了一个特殊的API，可以使用该API在函数内部，判断该函数是否使用了new来调用

	new.target 
	//该表达式，得到的是：如果没有使用new来调用函数，则返回undefined
	//如果使用new调用函数，则得到的是new关键字后面的函数本身
	


	function Person(firstName, lastName) {
	    //判断是否是使用new的方式来调用的函数
	
	    // //过去的判断方式
	    // if (!(this instanceof Person)) {
	    //     throw new Error("该函数没有使用new来调用")
	    // }
	
	    if (new.target === undefined) {
	        throw new Error("该函数没有使用new来调用")
	    }
	    this.firstName = firstName;
	    this.lastName = lastName;
	    this.fullName = `${firstName} ${lastName}`;
	}
	
	const p1 = new Person("袁", "进");//此时由于正常调用所以并没有任何问题
	console.log(p1)
	
	
	
	const p2 = Person("袁", "进");
	//在这里无论是直接调用还是通过call来改变this指向，所返回的数据都是undefined
	console.log(p2);
	
	const p3 = Person.call(p1, "袁", "进")//同理
	console.log(p3);

内层判断：如果内层不加if判断，就会实例化多次，这是显而易见的，这就违背了单例模式的单例二字。

外层判断：试图想想一种情况，当线程1走完了内层判断，对象实例化了，线程3也调用了getInstace函数，如果没有加外层的判断线程3还是要继续等待线程2的完成，而加上外层判断，就不需要等待了，直接返回了实例化的对象。

我的理解：外层的判断是为了提高效率【不必synchronized等待】，里层的判断就是第一次实例化需要。

转自：https://blog.csdn.net/weixin_38983929/article/details/103006376

Java volatile作用

Java单例模式 双重校验锁 为啥要用volatile修饰

内层判断：如果内层不加if判断，就会实例化多次，这是显而易见的，这就违背了单例模式的单例二字。

外层判断：试图想想一种情况，当线程1走完了内层判断，对象实例化了，线程3也调用了getInstace函数，如果没有加外层的判断线程3还是要继续等待线程2的完成，而加上外层判断，就不需要等待了，直接返回了实例化的对象。

我的理解：外层的判断是为了提高效率，里层的判断就是第一次实例化需要。