Java 面向对象 现在一般的语言都支持面向对象，而java更是将其做到很过分的地步，java是强制使用面向对象的写法，简单的写一个Hello Word都必须使用面向对象，这也是当初我很反感它的一点，当然现在也是很不喜欢它这一点。但是不得不说它设计的很优秀也很流行。面向对象面向对象一般是将一些独立有相似功能的模块封装起来组成一个类，然后调用者不必关注实现细节而只需要关注调用某个类方法即可。面向对象简化了程序设计。与之相对应的是面向过程，而C就是典型的面向过程的程序设计语言。面向对象一般有3种特性：封装、继承、多态。这次主要讲述的是java中的封装型。在java中类的定义与C++中类的定义类似，只是在java中每定义一个方法或者成员变量都需要在前面添加一个访问的权限修饰符，比如下面的定义class Student { private String name; private int age; public Student(){ } public Student(String name, int age){ this.name = name; this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } }而C++中只需要将具有相同访问属性的放到一块，用一次修饰符即可。比如上面java代码对应的C++代码如下:class Student { private: string name; int age; public: Student(){ } Student(string name, int age){ this->name = name; this->age = age; } int getAge(){ return this->age; } String getName(){ return this->name; } void setAge(int age){ this->age = age; } void setName(String name){ this->name = name; } }访问权限在C++中类中的成员如果不给访问权限，默认是private, 而java中默认的访问权限是friendly，但是这个friendly在java中并不是关键字，而且java中的public、private、protected 都必须明确指定，在java中这些关键字对应的访问权限如下:访问权限当前类同一个package子孙类其他packagepublicyesyesyesyesprotectedyesyesyesnofirendlyyesyesnonoprivateyesnonono从上一个表中可以看到public 对于类成员的访问完全没有限制、而protected仅仅保护类成员不被其他包访问，默认的friendly只允许同一个包或者同一个类的成员访问，最后的private仅允许同一个类的成员访问，它们的访问权限是递增的，也就是public > protected > friendly > private封装性面向对象的封装性就体现在仅仅允许通过类方法访问类成员。这有助于保护类成员不被其他代码随意的篡改，而且如果类成员在进行修改时如果会涉及到其他变化，我们只需要在get/set方法中控制即可，不需要外部使用人员了解这个细节。假设现在有一个教务系统，里面需要存储学生的信息，那么如果不采用封装的方式而直接在类代码外进行访问的话，而且成员被访问的位置较多，一旦发现数据库中存储的数据发生错误，那么将无法确定是在哪给定了错误的值，而且要对输入值进行判断的时候，每个被访问的位置都要添加这些判断的代码，修改量较大，而且无法保证每个位置都正常修改了。如果后续业务逻辑修改，那么这些工作又得重新做一遍。如果我们将成员变量使用set和get方法进行封装，查看数据错误的问题只需要关注get/set方法，而且业务逻辑变更时只需要修改get/set方法。这点体现了封装性对数据的保护作用。在假设这里我们采用多线程的方式来访问数据，那么为了保护数据，就需要添加相应的同步代码，如果直接访问，那么每当访问一次数据，就需要添加保护代码。这样就为使用人员添加了不必要的麻烦，如果我们将这些进行封装，然后告诉使用人员，这个类是线程安全的，那么使用人员直接调用而不用管其中的细节，后续如果我们换一种同步的方式，也不影响其他人的使用。this关键字C++中this关键字就是一个指针，通过eax寄存器传入到类的成员函数中，在成员函数中，通过this + 偏移地址来定位类中所有成员。而java中this除了能像c++中那样用于表示访问类成员外，还有另外两个作用使用this表示调用类其他的构造函数,比如下面的代码:class Student { private String name; private int age; public Student(){ } public Student(String name){ this(); //调用无参构造 this.name = name; } public Student(String name, int age){ this(name); // 调用有一个参数的构造方法 this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } }用来表示类的对象，其实这个作用与C++中this指针的作用相同，而且二者本质也一样，只是Java中不能直接访问内存地址，所以这里与C++有些许不同。class Student { private String name; private int age; public Student(){ } public Student(String name){ this(); //调用无参构造 this.name = name; } public Student(String name, int age){ this(name); // 调用有一个参数的构造方法 this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } public boolean compare(Student stu){ return this == stu; //这里简单实用二者的地址进行比较 } }构造函数与析构函数java中的构造函数与C++中的相同。是在new对象的时候调用的函数。注意这里只是说它在new的时候调用的函数，并不是在使用类的时候第一次调用的函数。Java 中的构造方法必须与该类具有相同的名字，并且没有方法的返回类型。每个类至少有一个构造方法。如果不写一个构造方法，Java 编程语言将提供一个默认的，该构造方法没有参数，而且方法体为空。如果一个类中已经定义了构造方法则系统不再提供默认的构造方法。java中不能直接访问内存，虽然它的类都是new出来的，但是资源的回收由垃圾回收机制来完成，那么它有析构函数吗？答案是肯定的，java中也是有析构函数的。在C++中进行栈资源回收或者手工调用delete的时候才会进行析构函数的调用。而在java中，当垃圾回收器将要释放无用对象的内存时，先调用该对象的finalize（）方法。这个finalize方法就是类的析构函数，这个方法是由Object这个基类提供的一个方法，Object子类可以选择重写它或者就用默认的。这个方法严格上应该是一个接口函数，与C++的析构并不相同。Java 虚拟机的垃圾回收操作对程序完全是透明的，因此程序无法预料某个无用对象的finalize（）方法何时被调用。类的静态代码块上面说构造函数并不是使用类时第一个调用的函数，第一个调用的函数应该是静态代码块（这个代码块应该不能被称之为函数）。静态代码块是第一次使用类的时候被调用，而且仅仅只调用这一次。它的定义如下:class Student{ staic { System.out.println("调用静态代码块"); } }

Java 函数 之前的几篇文章中，总结了java中的基本语句和基本数据类型等等一系列的最基本的东西，下面就来说说java中的函数部分函数基础在C/C++中有普通的全局函数、类成员函数和类的静态函数，而java中所有内容都必须定义在类中。所以Java中是没有全局函数的，Java里面只有普通的类成员函数（也叫做成员方法）和静态函数（也叫做静态方法）。这两种东西在理解上与C/C++基本一样，定义的格式分别为:public static void test(arglist){ } public void test(arglist){ }基本格式为：修饰符 [static] 返回值 函数名称 形参列表修饰符主要是用来修饰方法的访问限制，比如public 、private等等；如果是静态方法需要加上static 如果是成员方法则不需要；后面是返回值，Java函数可以返回任意类型的值；函数名用来确定一个函数，最后形参列表是传递给函数的参数列表。函数中的内存分布Java中函数的使用方式与C/C++中基本相同，这里就不再额外花费篇幅说明它的使用，我想将重点放在函数调用时内存的分配和使用上，更深一层了解java中函数的运行机制。我们说在X86架构的机器上，每个进程拥有4GB的虚拟地址空间。Java程序也是一个进程，所以它也拥有4GB的虚拟地址空间。每当启动一个Java程序的时候，由Java虚拟机读取.class 文件，然后解释执行其中的二进制字节码。启动java程序时，在进程列表中看到的是一个个的Java虚拟机程序。java虚拟机在加载.class 文件时将它的4GB的虚拟地址空间划分为5个部分，分别是栈、堆、方法区、本地方法栈、寄存器区。其中重点需要关注前3个部分。栈：与C/C++中栈的作用相同，就是用来保存函数中的局部变量和实参值的。堆：与C/C++中堆的作用相同，用来存储Java中new出来的对象方法区：用来保存方法代码和方法名与地址的这么一张表，类似于C/C++中的函数表基本数据类型作为函数的参数class Demo{ public static void main(String[] args){ int n = 10; test(10); System.out.println(n); } public static void test(int i){ System.out.println(i); i++; } }上述代码在函数中改变了形参值，那么在调用之后n的值会不会发生变化呢？答案是：不会变化，在C/C++中很好理解，形参i只是实参n的一个拷贝，i改变不会改变原来的n。这里我们从内存的角度来回答这个问题如上图所示，方法区中存储了两个方法的相关信息，main和test，在调用main的时候，首先从方法区中查找main函数的相关信息，然后在栈中进行参数入栈等操作。然后初始化一个局部变量n，接着调用test函数，调用test函数时首先根据方法区中的函数表找到方法对应的代码位置，然后进行栈寄存器的偏移为函数test分配一个栈空间，接着进行参数入栈，这个时候会将n的值——10拷贝到i所在内存中。这个时候在test中修改了i的值，改变的是形参中拷贝的值，与n无关。所以这里n的值不变引用类型作为函数参数class Demo{ public static void main(String[] args){ String s = "Hello"; test(s); System.out.println(s); //"Hello" } public static void test(String s){ System.out.println(s); //"Hello" s = "World"; } }在C/C++中，经常有这么一句话：“按值传递不能改变实参的值，按引用传递可以改变实参的值”，我们知道String 是一个引用，那么这里传递的是String的引用，我们在函数内部改变了s的值，在外部s的值是不是也改变了呢？我们首先估计会打印一个 "Hello"、一个"World"; 实际运行结果却是打印了两个 "Hello",那么是不是有问题呢？Java中到底存不存在按引用传递呢？为了回答这个问题，我们还是来一张内存图：从上面的内存图来看，在函数中修改的仍然是形参的值，而对实参的值完全没有影响。如果想做到在函数中修改实参的值，请记住一点：拿到实参的地址，通过地址直接修改内存。下面再来看一个例子:class Demo{ public static void main(String[] args){ int[] array = new int[]{1, 2, 3, 4, 5}; test(array); for(int i = 0; i < array.length; i++){ System.out.print(array[i]); } System.out.println(); //98345 } public static void test(int[] array){ for(int i = 0; i < array.length; i++){ System.out.print(array[i]); } System.out.println(); //12345 array[0] = 9; array[1] = 8; } }运行这个实例，可以看到这里它确实改变了，那么这里它发生了什么？跟上面一个字符串的例子相比有什么不同呢？还是来看看内存图这段代码执行的过程中经历了3个主要步骤:new一个数组对象，并且将数组对象的地址赋值给array 实参调用test函数时将array实参中保存的地址复制一份压入函数的参数列表中在test函数中，通过这个地址值来修改对应内存中的内容这段代码与上面两段本质上的区别在于，这段代码通过引用类型中保存的地址值找到并修改了对应内存中内容，而上面的两段代码仅仅是在修改引用类型这个变量本身的值。说到传递引用类型，那么我就想到在C/C++中一个经典的漏洞——缓冲区溢出漏洞，那么java程序中是否也存在这个问题呢？这里我准备了这样一段代码:class Demo{ public static void main(String[] args){ byte[] buf = new byte[7]; test(buf); } public static void test(byte[] buf){ for(int i = 0; i < 10; i++){ buf[i] = (byte)i; } } }如果是在C/C++中，这段代码可以正常执行只是最后可能会报错或者崩溃，但是赋值是成功的，这也就留给了黑客可利用的空间。在Java中执行它会发现，它会报一个越界访问的异常，也就说这里赋值是失败的，不能直接往内存里面写，也就不存在这个漏洞了。返回引用类型Java方法返回基本类型的情况很简单，也就是将函数返回值放到某块内存中，然后进行一个复制操作。这里重点了解一下它在返回引用类型时与C/C++不同的点在C/C++中返回一个类对象的时候，会调用拷贝构造将需要返回的类对象拷贝到对应保存类对象的位置，然后针对函数中的类对象调用它的析构函数进行资源回收，那么Java中返回类对象会进行哪些操作？C/C++中返回一个类对象的指针时，外部需要自己调用delete或者其他操作进行析构。java中的类对象都是引用类型，在函数外部为何不需要额外调用析构呢？带着这些问题，来看下面这段代码：class Demo{ public static void main(String[] args){ String s = test(); System.out.println(s); } public static String test(){ // return new String("hello world"); return "Hello World"; } }这段代码 不管是用new也好还是直接返回也好，效果其实是一样的，下面是对应的内存分布图这段代码首先在函数test中new一个对象，此时对应在堆内存中开辟一块空间来保存"hello world" 值，然后保存内存地址在寄存器或者其他某个位置，接着将这个地址值拷贝到main函数中的s中，最后回收test函数的栈空间。这里实质上是返回了一个堆中的地址值，这里就回答了第一个问题：在返回类对象的时候其实返回的值对象所在的堆内存的地址。接着来回答第二个问题：java中资源回收依赖与一个引用计数。每当对地址值进行一次拷贝时计数器加一，当回收拷贝值所在内存时计数器减一。这里在返回时，先将地址值保存到某个位置（比如C/C++中是将返回值保存在eax寄存器中）。此时计数器 + 1；然后将这个值拷贝到 main 函数的s变量中，此时计数器的值再 + 1，变为2，接着回收test函数栈空间，计数器 - 1，变为1，在main函数指向完成之后，main的栈空间也被回收，此时计数器 - 1，变为0，此时new出来的对象由Java的垃圾回收器进行回收。

Java 基本语句、控制结构 上一篇中简单谈了一下自己对Java的一些看法并起了一个头，现在继续总结java的相关语法。java语法总体上与C/C++一样，所以对于一个C/C++程序员来说，天生就能看懂Java代码。在学习java的时候，上手非常快。我感觉自己就是这样，看代码，了解其中一些重点或者易错点的时候发现，与C/C++里面基本类似，甚至很多东西不用刻意去记，好像自己本身就知道坑在哪。所以这里我想简单列举一下语法点，然后尝试用C/C++的视角来解读这些特性。引用类型引用中的指针与内存上一次，我总结一下java中的数据类型，在里面提到，Java中有两大数据类型，分为基本数据类型和引用数据类型。并且说明了简单数据类型，这次就从引用数据类型说起；引用数据类型一般有：数组、字符串、类对象、接口、lambda表达式；这次主要通过数组和字符串来说明它引用数据类型在C/C++中对应指针或者引用。其实关注过我之前C/C++反汇编系列文章的朋友知道，在C/C++中引用实质上就是一个指针。所以这里我也将java中引用类型理解为指针。所以从本质上讲，引用类型都是分配在堆上的动态内存。然后使用一个指针指向这块内存。这是理解引用类型很重要的一点。数组的定义如下char[] a = new char[10]; char[] b = new char[] {'a', 'b', 'c'}; char[] c = {'a', 'b', 'c'};其实这种形式更符合 变量类型 变量名 = 变量值 这种语法结构， char[] 就像是一种数据类型一样，char表示数组中元素类型， []表示这是一个数组类型字符串的简单定义如下:String s = "Hello world";上面说到引用类型都是分配在堆上的。所以字符串和数组实质上都是new 出来的。即使有的写法上并没有new 这个关键字，但是虚拟机还是帮助我们进行了new 操作。有new就一定有delete了。那么哪里会delete呢？这些操作一般都由java的垃圾回收器来处理。我们只管分配。这就帮助程序员从资源回收的工作中解放出来了。这也是java相比于C/C++来说比较优秀的地方。有人可能会说C++中有智能指针，也有垃圾回收机制。确实是这样。但是我觉得还是有点不一样。java是天生就支持垃圾回收，就好像从娘胎生出来就有这个本能，而C/C++是由后天学会的，或者说要刻意的去进行操作。二者还是不一样的。下面有这样一段代码:char[] a = new char[10]; System.out.println(a);我们打印这个a变量，发现它出现的是一个类似16进制数的一个东西。这个东西其实是一个地址的hash值，为什么不用原始值呢？我估计是因为有大神能够根据变量的内存地址进行逆向破解，所以这里为了安全对地址值进行了一个加密。或者为了彻底贯彻Java不操作内存的信念。（我这个推断不知道是不是真的，如果有误，请评论区大牛指正。）这也就证明了我之前说的，引用类型本质上是一个指针。char[] a = new char[]{'a', 'b', 'c'}; char[] b = new char[]{'a', 'b', 'c'}; System.out.println(a); System.out.println(b);上面这段代码，我想学过C/C++的人应该一眼就能看出，这里打印出来的a和b应该是不同的值，这里创建了两块内存。只是内存中放的东西是一样的。char[] a = new char[]{'a', 'b', 'c'}; char[] b = a; b[0] = '0'; b[1] = '1'; b[2] = '2'; System.out.println(a); System.out.println(b);这里从C/C++的角度来看，也很容易理解：定义了两个引用类型的变量，a、b都指向同一块内存，不管通过a还是b来寻址并写内存，下次通过a、b访问对应内存的时候肯定会发现值与最先定义的不同。String s = "hello"; System.out.println(s.hashCode()); s += "world"; System.out.println(s.hashCode());由于Java不具备直接访问内存的能力，不能直接打印出它的内存地址，所以这里用hashCode 得到地址的hash值。通过打印结果说明这个时候s指向的地址已经变了。也就是说虽然可以实现字符串的拼接，但是虚拟机在计算得出拼接的结果后又分配了一块内存用来保存新的值。但是任然用s这个变量来存储地址值，用赵本山的话来说就是“大爷还是那个大爷，大妈已经不是原来的那个大妈了”。也就是说Java分配内存的时候应该是按需分配，需要多少分配多少。不够就回收之前的，再重新按需分配。这就导致了java中字符串和数组的长度是不能改变的。String s = "hello"; System.out.println(s.hashCode()); (s.toCharArray())[0] = 'H'; System.out.println(s.hashCode()); System.out.println(s); // 这里字符串的值不变上述这段代码，通过toCharArray将字符串转化为char类型的数组，然后修改数组中的某一个元素的值，我原来以为这样做相当于在String所在内存中修改，最终打印s时会出现 "Hello" ，但是从结果上来看并没有出现这样的情况，s指向的地址确实没变，但是s也是没变的，那只能解释为toCharArray 又开辟了一块内存，将String中的值一一复制到数组中。在学习中我尝试过各种数据类型强转String s = "Hello World"; char[] a = (char[]) s; int p = (int)s;像这样的代码我发现并不能通过编译。在C/C++中，可以进行任意类型到整型或者指针类型的转化，常见的转化方式就是将变量所在地址进行赋值或者将变量对应的前四个字节进行转化作为int或者指针类型。但是在java中这点好像行不通。Java中强转好像只能在基本数据类型中实现，而在引用类型中通常由函数完成，并且完成时并不是简单的赋值，还涉及到新内存空间的分配问题。越界访问由于C/C++中提供了访问内存的能力，而且由于现代计算机的结构问题，C/C++中存在越界访问的问题，越界访问可以带来程序编写的灵活性，但是也带来的一些安全隐患。对于灵活性，相信学习过Windows或者Linux编程的朋友应该深有体会，系统许多数据结构的定义经常有这类:struct s { char c; } s *p = (s*)new char[100]; 这样就简单的创建了一个字符串的结构。这里C变量只是提供了一个地址值，后续可以根据c的地址来访问它后续的内存。安全问题就是大名鼎鼎的缓冲区溢出漏洞，我在相关博客中也详细谈到了缓冲区溢出漏洞的危害以及基本的利用方式。这里就不在赘述。那么Java中针对这种问题是如何处理的呢? Java中由于不具有内存访问的能力，所以这里它简单记录当前对象的长度，只要访问超过这个长度，立马就会报异常，报一个越界访问的异常。（这里我暂时没有想到对应的java演示代码，所以简单说一下吧）空指针访问还记得C/C++指针中常见的一个NULL吧，既然Java中引用类型相当于一个指针，那么它肯定也存在空指针问题。在Java中空指针定义为null。如果直接访问null引用，一般会报空指针访问异常。char[] c = null; c[0] = 'A'; //异常语句关于引用类型我暂时了解了这么多东西。下面简单列举一下java中的运算符和相关语句结构运算符java中的运算符主要有下列几个:算数运算符: + 、-、 *、 /、 %、 ++、 --、赋值运算符: = 、+=、 -=、%=、/=、*=比较运算符: ==、 >、 <、 >=、 <=、 !=逻辑运算符: &&、 ||、 !、三目运算符位运算符: >>、 <<、 >>>(无符号右移)、 <<<、&、|、~这些运算符用法、要点、执行顺序与C/C++中完全相同。所以这里简单列举。不做任何说明语句结构java中的顺序结构与其他语言中一样，主要有3种顺序结构判断结构: if、if...else、 if...else if...else if...else循环结构：while、for、do while用于与其他语言一样，这里需要注意的是，Java中需要判断的地方只能使用bool值作为判断条件，比如 5 == 3 、 a == 5这样的。在C/C++中有一条编程规范，像判断语句中将常量写在前面就像这样if(5 == a){ //.... }这样主要是为了防止将 == 误写成 = ，因为在C/C++中 只要表达式的值不为0 就是真，像 if(a = 5) 这样的条件是恒成立的。而Java中规定判断条件必须是真或者假，并且规定boolean类型不能转化为其他类型，其他类型也不能转化为boolean，所以 if(a = 5) 这样的语句在Java中编译是不会通过的。

java基础语法 最近抽时间在学习Java，目前有了一点心得，在此记录下来。由于我自己之前学过C/C++，而Java的语法与C/C++基本类似，所以这一系列文章我并不想从基础一点点的写，我想根据我已有的C/C++经验，补充一些需要注意的点，或者java中独特的内容，或者将C/C++进行对比来总结一下学习的内容。为什么要学习java最开始接触到Java还是在学校中开设的一门java编程语言的课，那个时候感觉java很麻烦，写个helloworld要那么多代码。后来学到web编程，我自己搭建的环境总是报错，而且还是jar包的错误。从这个时候起，我对java就没什么好感。后来很多培训机构来学校招生，做讲演，难道大学学了4年，最后还是去了培训机构，而那些培训机构号称4个月完全掌握java，这时我感觉如果我去学了java，那么大学4年出来跟培训班4个月出来有什么差别，既然上了大学，学了计算机，要跟培训机构出来的人不一样，既然是学计算机的，当然得学计算机里面最难的语言，所以我大学从3年级开始学了大半年汇编，又从汇编转到C和C++。但是万事逃不过真香定律，在工作之后，慢慢接触了Java，也了解了java，其实Java并不像我想想的那么简单。但是我心里一直抗拒学它。但是最近工作中确实要用到它，之前在一些博文中提到过，现在我开始带领几个人的小队，里面有java的，有做C的，有Python的，我想作为一个leader，虽然不用干他们的活，但是至少得懂。最主要的还是Java那边提个需求实在太难，java程序员总会跟我说很难，要改代码，动不动就说这个需求得改架构。最后做出来的跟我预计的差别太大。为了有理有据的回怼，也为了更好的带队，我想Java还是得会。说到这里我有感而发：领导给你活，并不是要听你抱怨有多难，要很多东西。既然能告诉你要做这个，那么可行性方面肯定提前做过研究，不要说什么很难，做不了。既然给你了，领导要的是你提出一个解决方案，然后告诉我要多长时间。中间出了问题及时反馈就OK。一直抱怨难，动不动就改架构什么的，只会让领导对你的个人能力产生怀疑，甚至会萌发出换人的想法。所以领导拍下来的活，干就对了。上述是一个原因，还有一个原因；我在关注安全漏洞的时候经常会报出来什么Struts2 漏洞、WebLogic 漏洞，这些都是java的开发框架，很多时候大牛们的博客或者公众号上已经写了漏洞原理，甚至有的还有它验证以及构造POC的思路，但是我就是看不懂，不出POC，我完全不知道如何去检测。为了以后能更好的理解这些java漏洞，我想还是需要好好学一下Java从hello world 开始任何语言都是从hello world开始的，java也不例外，这里我给出hello world的代码public class HelloWorld{ public static void main(String[] args){ System.out.println("hello world"); } }将这段代码保存到HelloWord.java文件中，这里文件的名称必须是HelloWorld.java，文件名与主类的名称相同。然后调用javac进行编译javac HelloWorld.java这个时候会生成.class 文件，这里使用java执行代码java HelloWorld注意执行的时候java指令后面跟的是类名而不是具体的.class文件名。这里我想应该是在执行的时候，java命令根据类名去找对应的.class 文件，将文件中的二进制字节码放到虚拟机中执行。然后由虚拟机去类中查找main函数，从main函数中执行。因此这里文件名必须与类名相同，而且必须要有main函数。再来说说这个main函数前面的修饰词，public 应该表示这个是一个公共方法，也就是外部可以访问，static 表示这个方法是一个静态方法，独立与类存在的。这两个修饰符是必须的要的。java强制使用面向对应，一切都定义在类中，但是程序必须要一个入口函数。根据java的逻辑，这个main函数也得定义到类中。但是如果定义成普通函数的话行不行呢。答案是不行的，由于main函数是一个入口函数，一切都从它开始，如果它是一个类函数，那么势必要定义一个类的对象然后再调用对象的main方法，可是既然main是程序的开始，请问如何在调用main之前定义对象呢，因此这里必须得定义成静态的；这个public能不能不加或者改成private或者其他的呢？当然也不行，既然你要将它作为入口函数，那么必然需要由虚拟机调用这个函数，而且是在类外调用，所以这里一定得定义成public，对外开放。在Java中一切即对象，它强制你采用面向对象，这也是当时我拒绝学java的一个理由，认为它太死板。java的跨平台据说SUN公司当年是卖服务器，服务器上的主要程序是由C/C++开发而来的，而C/C++，每次在换一个平台都需要重新编译。这个时候SUN公司的工程师需要一种跨平台的语言，就那种代码写完，编译完成之后不需要再做任何操作，随便放到一个平台上都能跑的那种。而且当时C++ 指针、多继承满天飞，造成程序编写、理解的困难。基于这几点理由，开发出了Java，Java脱胎于C++，但是砍掉了C++中复杂的指针和多继承的内容，在现在看来应该是一个比较正确的决定。相比于现在C++各种新特性的眼花缭乱，java还是很朴实很简单的东西。java的跨平台取决于它的虚拟机。每个平台都需要一个对应的虚拟机。虚拟机就好像一个翻译，而程序就像一个到不同国家旅行的人，比如说一个中国游客可以去美国、去日本、去英国旅行，他在酒店前台时用中文吩咐前台的工作人员给他一间房，去不同的国家有不同的翻译将开房这条指令翻译为前台能听懂的语言。而我们的游客只需要说中文即可。java的虚拟机的工作原理也是这样的。按照统一的规则，根据具体的平台将规则中定义的指令翻译为对应平台上的机器码。比如在Windows上+1操作是 ADD 1, 在Linux上+1操作是 +1， 而在MAC中对应 1+ ，那么在java代码中这个指令可能会编译为 1++, 这个指令不管在哪个平台都不用变，当它放在windows主机上由Windows版的虚拟机将它翻译为 ADD 1,在Linux上由Linux版的虚拟机翻译为+1，在MAC上由MAC版的虚拟机翻译为 1+。java代码执行需要经过两个步骤，首先编译为虚拟机能识别的字节码，然后有虚拟机解释并执行这个字节码。所以java具有两面性，即需要编译，也需要解释执行，那么它到底是解释性的语言还是编译型的呢？我也不知道。基本语法它的语法与C/C++基本类似，类似到你即使没接触过java，看它的代码基本能看懂每条语句都在干嘛。所以针对我来说，我并不关注每个代码怎么写，我只需要知道每个语法点有哪些需要注意的即可。常量与变量常量在java中一般是指那种用字面值表示出来的量比如说 整型的1,浮点型的1.234, 字符 'A' 字符串 'hello world'，或者是用关键字 const 定义的。java里面的常量分为：整型常量、字符串常量、浮点数常量、字符常量、布尔常量和空常量(null)。从常量类型可以看出这些也是java中主要的数据类型，java中数据类型主要有:整数类型: byte、short、int、long浮点数类型: float、double字符类型: char布尔类型:boolean这些都是基本数据类型，java中还有引用类型，像字符串、对象、数组、接口、lambda表达式都是引用类型。需要注意的是java中long 是8个字节，而C/C++中long一般是4个字节，longlong才是8个。java中的char占两个字节，所以在C/C++中会将需要一个字节一个字节处理的缓冲定义为char型数组，而在java中就不能这么干了，因为它的char占两个字节，java中对于这种情况一般是定义为byte类型的数组。由于java中的char占两个字节，所以java中char是可以表示中文的char c = '中' //这在java中是正确的，但是C/C++中不能这么写有数据类型自然就涉及到数据类型转化的问题。java与C/C++类似都有显示转化和隐式转化。而且写法也类似。需要注意的几点是:整型字面值会被java编译器默认当做int类型来处理，像 byte num = 5、short s = 5 这样的表达式中5 这个字面值都是int，也就是它里面都发生了强制类型转化，如果想让编译器将其当做long需要在5后面加上L，写成 long l = 5L浮点数字面值会被默认当做double 来处理，如果想让其被作为float处理，需要在后面加上F在进行整数运算的时候，运算符号两侧的变量 或者常量会被先转化为int 在进行处理。例如 下面的代码:short s1 = 5, s2 = 10; short result = s1 + s2;这段代码java会报错，由于在运算的时候s1 与 s2 会被转化为int，然后运算得到的结果也是int，在最后进行结果赋值的时候将int赋值为short会发生错误。要让他不报错可以改为 short result = (short)(s1 + s2);隐式类型转化发生在由表示范围小的向表示范围大的类型，一般是 byte-->short-->int-->long-->float-->double。再来看下面一个例子:short n = 5 + 10;这段代码，从理论上讲，它应该会首先把5 和 10 转化为int，在计算，最后把结果的int转化为short赋值，根据上面说的，它应该会报错才对，但是实际试验的结果却是，它通过了。这就很奇怪了。还记得在学习C/C++中提到的编译器的优化吗。在C/C++中如果你写上面的一段代码，在release版本中，你看不到类似mov eax, 5 add eax, 10 mov n, eax这样的机器指令，只看得到mov n, 15这里编译器进行了优化，你代码中采用了字面值常量进行相加，而常量是不会变化的，因此在程序运行之前就已经知道计算的结果，我就没必要在运行的时候浪费CPU给你计算这个加法值，我直接给你一个结果也是一样的。所以这里java编译器采用了同样的策略。它直接将上面的代码翻译为了 short n = 15。但是这也不对啊，15应该会被当做int，而n是一个short，将int这个表示范围大的转化为short这个表示范围小的，应该会报错才对啊。但是编译确实不报错。这又涉及到java编译器的另一个策略了。当我们直接用字面值常量进行赋值操作的时候，如果字面值没有超过左侧变量的表示范围时，编译器会自动进行强制类型转化。最后的最后我想在你已经拥有其他语言的开发经验的时候，学习新语言的过程无外乎是数据类型、基本语句、控制结构、函数、面向对象、以及常用库这些东西，所以我想我自己的java笔记也按照这些框架来组织。这次是数据类型，下次就是基本语句与控制结构了。

COM学习（四）——COM中的数据类型 上一次说到，COM为了跨语言，有一套完整的规则，只要COM组件按照规则编写，而不同的语言也按照对应的规则调用，那么就可以实现不同语言间相互调用。但是根据那套规则，只能识别接口，并调用没有参数和返回类型的接口，毕竟不同语言里面的基本数据类型不同，可能在VC++中char * 就表示字符串，而在Java或者c#中string是一个对象，二者的内存结构不同，不能简单的进行内存数据类型的强制转化。为了实现数据的正常交互，COM中又定义了一组公共的数据类型。HRESULT类型：在COM中接口的返回值强制定义为该类型，用于表示当前执行的状态是完成或者是出错，这个类型一般在VC中使用，别的语言在调用时根据接口的这个值来确定接下来该如何进行。HRESULT类型的定义如下：typedef _Return_type_success_(return >= 0) long HRESULT;其实它就是一个32位的整数，微软将这个整数分成几个部分，各个部分都有详细的含义，这个值的详细解释在对应的winerror.h中。// // Note: There is a slightly modified layout for HRESULT values below, // after the heading "COM Error Codes". // // Search for "**** Available SYSTEM error codes ****" to find where to // insert new error codes // // Values are 32 bit values laid out as follows: // // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 // +-+-+-+-+-+---------------------+-------------------------------+ // |S|R|C|N|r| Facility | Code | // +-+-+-+-+-+---------------------+-------------------------------+ // // where // // S - Severity - indicates success/fail // // 0 - Success // 1 - Fail (COERROR) // // R - reserved portion of the facility code, corresponds to NT's // second severity bit. // // C - reserved portion of the facility code, corresponds to NT's // C field. // // N - reserved portion of the facility code. Used to indicate a // mapped NT status value. // // r - reserved portion of the facility code. Reserved for internal // use. Used to indicate HRESULT values that are not status // values, but are instead message ids for display strings. // // Facility - is the facility code // // Code - is the facility's status code // // // Define the facility codes //根据上面的注释可以看到，以及我自己查阅相关资料，它里面总共有7个部分，各个部分代表的含义如下：S - 严重性 - 表示成功或失败0 - 成功，1 - 失败R - 设施代码的保留部分，对应于NT的第二严重性位。1 - 严重故障C - 第三方。 此位指定值是第三方定义还是Microsoft定义的。0 - Microsoft-定义，1 - 第三方定义N - 保留部分设施代码。 用于指示映射的NT状态值。X - 保留部分设施代码。 保留供内部使用。 用于指示不是状态值的HRESULT值，而是用于显示字符串的消息标识。Facility - 表示引发错误的系统服务. 示例Facility代码如下所示：2 - 调度（COM调度）3 - 存储 (OLE存储)4 - ITF (COM/OLE 接口管理)7 - (原始 Win32 错误代码)8 - Windows9 - SSPI10 - 控制11 - CERT (客户端或服务器认证)...Code - 设施的状态代码其实这些没有必要知道的很详细，只需要知道里面常用的几个即可：S_OK：成功S_FALSE：失败E_NOINTERFACE:没有接口，一般是由QueryInterface或者CoCreateInterface函数返回，当我们传入的ID不对它找不到对应的接口时返回该值E_OUTOFMEMORY:当内存不足时返回该值。一般在COM的调用者看来，有的时候只要最高位不为0就表示成功，这个时候可能会继续使用，所以在我们自己编写组件的时候要根据具体情况选择返回值，不要错误了就返回S_FALSE，其实我们看它的定义可以知道它是等于1的，最高位为0，仍然是成功的。如果返回S_FALSE可能会造成意想不到的错误，而且还难以调试。BSTRCOM中规定了一种通用的字符串类型BSTR，查看BSTR的定义如下：typedef /* [wire_marshal] */ OLECHAR *BSTR; typedef WCHAR OLECHAR;从上面的定义上不难看出BSTR其实就是一个WCHAR ,也就是一个指向宽字符的指针。COM中使用的是UNICODE字符串，在编写COM程序的时候经常涉及到CString、WCHAR、char等的相互转化，其实本质上就是多字节字符与宽字节字符之间的转化。我们平时在进行char 与WCHAR*之间转化的函数像WideCharToMultiByte和MultiByteToWideChar，以及W2A和A2W等。COM为了方便使用，另外也提供了一组转化函数_com_util::ConvertBSTRToString以及_com_util::ConvertStringToBSTR用在在char*与BSTR之间进行转化。需要注意的是，这组函数返回的字符串是在堆上分配出来的，使用完后需要自己释放。在BSTR类型中，定义了两个函数SysAllocString(),和SysFreeString()用来分配和释放一个BSTR的内存空间。在这总结一下他们之间的相互转化：char*----->BSTR: _com_util::ConvertStringToBSTRWCHAR*---->BSTR:可以直接用 = 进行赋值，也可以使用SysAllocStringBSTR---->WCHAR:一般是直接使用等号即可，但是在WCHAR使用完之前不能释放，所以一般都是赋值给一个CStringBSTR---->char*:_com_util::ConvertBSTRToStringConvert函数是定义在头文件atlutil.h中并且需要引用comsupp.lib文件另外COM封装了一个_bstr_t的类，使用这个类就更加方便了，它封装了与char*之间的相互转化，可以直接使用赋值符号进行相互转化，同时也不用考虑回收内存的问题，它自己会进行内存回收。VARIANT 万能类型现代编程语言一般有强类型的语言和弱类型的语言，强类型的像C/C++、Java这样的，必须在使用前定义变量类型，而弱类型像Python这样的可以直接定义变量而不用管它的类型，甚至可以写出像:i = 0 i = "hello world"这样的代码，而且不同语言中可能同一种类型的变量在内存布局上也可能不一样。解决不同语言之间变量类型的冲突，COM定义了一种万能类型——VARIANT。typedef struct tagVARIANT VARIANT; typedef struct tagVARIANT VARIANTARG; struct tagVARIANT { union { struct __tagVARIANT { VARTYPE vt; WORD wReserved1; WORD wReserved2; WORD wReserved3; union { LONGLONG llVal; LONG lVal; BYTE bVal; SHORT iVal; FLOAT fltVal; DOUBLE dblVal; VARIANT_BOOL boolVal; _VARIANT_BOOL bool; SCODE scode; CY cyVal; DATE date; BSTR bstrVal; IUnknown *punkVal; IDispatch *pdispVal; SAFEARRAY *parray; BYTE *pbVal; SHORT *piVal; LONG *plVal; LONGLONG *pllVal; FLOAT *pfltVal; DOUBLE *pdblVal; VARIANT_BOOL *pboolVal; _VARIANT_BOOL *pbool; SCODE *pscode; CY *pcyVal; DATE *pdate; BSTR *pbstrVal; IUnknown **ppunkVal; IDispatch **ppdispVal; SAFEARRAY **pparray; VARIANT *pvarVal; PVOID byref; CHAR cVal; USHORT uiVal; ULONG ulVal; ULONGLONG ullVal; INT intVal; UINT uintVal; DECIMAL *pdecVal; CHAR *pcVal; USHORT *puiVal; ULONG *pulVal; ULONGLONG *pullVal; INT *pintVal; UINT *puintVal; struct __tagBRECORD { PVOID pvRecord; IRecordInfo *pRecInfo; } __VARIANT_NAME_4; } __VARIANT_NAME_3; } __VARIANT_NAME_2; DECIMAL decVal; } __VARIANT_NAME_1; };从定义上看出，它其实是一个巨大的联合体，将所有C/C++的基本类型都包含进来，甚至包含了像BSTR, 这样的COM中使用的类型。它通过成员vt来表示它当前使用的是哪种类型的变量。vt的类型是一个枚举类型，详细的定义请参见MSDN。为了简化操作，COM中也对它进行了一个封装——_variant_t,该类型可以直接使用任何类型的数据对其进行初始化操作。但是在使用里面的值时还是得判断它的vt成员的值COM中的其他操作最后附上一张COM常用函数表以供参考:

COM学习（三）——COM的跨语言 COM是基于二进制的组件模块，从设计之初就以支持所有语言作为它的一个目标，这篇文章主要探讨COM的跨语言部分。idl文件一般COM接口的实现肯定是以某一具体语言来实现的，比如说使用VC++语言，这就造成了一个问题，不同的语言对于接口的定义，各个变量的定义各不相同，如何让使用vc++或者说Java等其他语言定义的接口能被别的语言识别？为了达到这个要求，定义了一种文件格式idl——（Interface Definition Language）接口定义语言，IDL提供一套通用的数据类型，并以这些数据类型来定义更为复杂的数 据类型。一般来说，一个文件有下面几个部分说明接口的定义组件库的定义实现类的定义而各个部分又包括他们的属性定义，以及函数成员的定义属性：属性是在接口定义的上方，使用“[]”符号包裹，一般在属性中使用下面几个关键字:object:标明该部分是一个对象（可以理解为c++中的对象，包括接口和具体的实现类）uuid:标明该部分的GUIDversion：该部分的版本接口定义接口定义采用关键字interface，接口函数定义在一对大括号中，它的定义与类的定义相似，其中函数定义需要修饰函数各个参数的作用，比如使用in 表示它作为输入参数，out表示作为输出参数，retval表示该参数作为返回值，一般在VC++定义的接口中，函数返回值为HRESULT，但是需要返回一个值供外界调用，此时就使用输出参数并加上retval表示它将在其他语言中作为函数的返回值。组件库定义库使用library关键字定义，在定义库的时候，它的属性一般定义GUID和版本信息，而在库中通常定义库中的实现类的相关信息，库中的信息也是写在一对大括号中实现类的定义接口实现类使用关键字coclass，接口类的属性一般定义一个object，一个GUID，然后一般定义实现类不需要向在C++中那样定义它的各个接口，各个数据成员，只需要告知它实现哪些接口即可，也就是说它继承自哪些接口。下面是一个具体的例子：import "unknwn.idl"; [ object, uuid(CF809C44-8306-4200-86A1-0BFD5056999E) ] interface IMyString : IUnknown { HRESULT Init([in] BSTR bstrInit); HRESULT GetLength([out, retval] ULONG *pretLength); HRESULT Find([in] BSTR bstrFind, [out, retval] BSTR* bstrSub); }; [ uuid(ADF50A71-A8DD-4A64-8CCA-FFAEE2EC7ED2), version(1.0) ] library ComDemoLib { importlib("stdole32.tlb"); [ uuid(EBD699BA-A73C-4851-B721-B384411C99F4) ] coclass CMyString { interface IMyString; }; };上面的例子中定义了一个IMyString接口继承自IUnknown接口，函数参数列表中in表示参数为输入参数,out表示它为输出参数，retval表示该参数是函数的返回值。import导入了一个库文件类似于include。而importlib导入一个tlb文件，我们可以将其看成VC++中的#pragma comment导入一个lib库从上面不难看出一个IDL文件至少有3个ID，一个是接口ID，一个是库ID，还有一个就是实现类的ID在VC环境中通过midl命令可以对该文件进行编译，编译会生成下面几个我们在编写实现时会用到的重要文件:一个.h文件：包含各个部分的声明，以及接口的定义一个_i.c文件：包含各个部分的定义，主要是各个GUI的定义需要实现的导出函数一般我们需要在dll文件中导出下面几个全局的导出函数：STDAPI DllRegisterServer(void); STDAPI DllUnregisterServer(void); STDAPI DllGetClassObject(const CLSID & rclsid, const IID & riid, void ** ppv); STDAPI DllCanUnloadNow(void);其中DllRegisterServer用来向注册表中注册模块的相关信息，主要注测在HKEY_CLASSES_ROOT中，主要定义下面几项内容：字符串名称项，该项中包含一个默认值，一般给组件的字符串名称；CLSID子健，一般给实现类的GUID；CurVer子健一般是子健的版本以版本字符串为键的注册表项，该项中主要保存：默认值，当前版本的项目名称；CLSID当前版本库的实现类的GUID在HKEY_CLASSES_ROOT/CLSID子健中注册以实现类GUID字符串为键的注册表项，里面主要包含：默认值，组件字符串名称;InprocServer32，组件所在模块的全路径；ProgID组件名称；TypeLib组件类型库的ID，也就是在定义IDL文件时，定义的实现库的GUID。下面是具体的定义：const TCHAR *g_RegTable[][3] = { { _T("CLSID\\{EBD699BA-A73C-4851-B721-B384411C99F4}"), 0, _T("FirstComLib.MyString")}, //组件ID { _T("CLSID\\{EBD699BA-A73C-4851-B721-B384411C99F4}\\InprocServer32"), 0, (const TCHAR*)-1 }, //组建路径 { _T("CLSID\\{EBD699BA-A73C-4851-B721-B384411C99F4}\\ProgID"), 0, _T("FirstComLib.MyString")}, //组件名称 { _T("CLSID\\{EBD699BA-A73C-4851-B721-B384411C99F4}\\TypeLib"), 0, _T("{ADF50A71-A8DD-4A64-8CCA-FFAEE2EC7ED2}") }, //类型库ID { _T("FirstComLib.MyString"), 0, _T("FirstComLib.MyString") }, //组件的字符串名称 { _T("FirstComLib.MyString\\CLSID"), 0, _T("{EBD699BA-A73C-4851-B721-B384411C99F4}")}, //组件的CLSID { _T("FirstComLib.MyString\\CurVer"), 0, _T("FirstComLib.MyString.1.0") }, //组件版本 { _T("FirstComLib.MyString.1.0"), 0, _T("FirstComLib.MyString") }, //当前版本的项目名称 { _T("FirstComLib.MyString.1.0\\CLSID"), 0, _T("{EBD699BA-A73C-4851-B721-B384411C99F4}")} //当前版本的CLSID };使用上一篇博文的代码，来循环注册这些项即可DllGetClassObject:该函数用来生成对应的工厂类，而工厂类负责产生对应接口的实现类。DllCanUnloadNow：函数用来询问是否可以卸载对应的dll，一般在COM中有两个全局的引用计数，用来记录当前内存中有多少个模块中的类，以及当前有多少个线程在使用它，如果当前没有线程使用或者存在的对象数为0，则可以卸载实现类的定义实现部分的整体结构图如下：由于所有类都派生自IUnknown，所在在这里就不显示这个基类了。每个实现类都对应了一个它具体的类工厂，而项目中CMyString类的类厂的定义如下：class CMyClassFactory : public IClassFactory { public: CMyClassFactory(); ~CMyClassFactory(); STDMETHOD(CreateInstance)(IUnknown *pUnkOuter, REFIID riid, void **ppvObject); STDMETHOD(LockServer)(BOOL isLock); STDMETHOD(QueryInterface)(REFIID riid, void **ppvObject); STDMETHOD_(ULONG, AddRef)(void); STDMETHOD_(ULONG, Release)(void); protected: ULONG m_refs; };STDMETHOD宏展开如下：#define STDMETHOD(method) virtual HRESULT __stdcall method所以上面的代码展开后就变成了:virtual HRESULT __stdcall CreateInstance((IUnknown *pUnkOuter, REFIID riid, void **ppvObject);另外3个派生自IUnknown接口就没什么好说的，主要说说另外两个：CreateInstance：主要用来生成对应的实现类，然后再调用实现类——CMyString的QueryInterface函数生成对应的接口LockServer：当前是否被锁住：如果传入的值为TRUE，则表示被锁住，对应的锁计数器+1， 否则 -1至于CMyString类的代码与之前的大同小异，也就没什么说的。其他语言想要调用，以该项目为例，一般会经历下面几个步骤：调用对应语言提供的产生接口的函数，该函数参数一般是传入一个组件的字符串名称。如果要引用该项目中的组件则会传入FirstComLib.MyString在注册表的HKEY_CLASSES_ROOT\组件字符串名\CLSID（比如HKEY_CLASSES_ROOT\FirstComLib.MyString\CLSID）中找到对应的CLSID值在HKEY_CLASSES_ROOT\CLSID\对应ID\InprocServer32（CLSID\{EBD699BA-A73C-4851-B721-B384411C99F4}\InprocServer32）位置处找到对应模块的路径加载该模块根据IDL文件告知其他语言里面存在的接口，由语言调用对应的创建接口的函数创建接口调用模块的导出函数DllGetClassObject将查询到的CLSID作为第一个参数，并将接口ID作为第二个参数传入，得到一个接口6.后面根据idl文件中的定义，直接调用接口中提供的函数真实ATLCOM项目的解析最后来看看一个正式的ATLCOM项目里面的内容，来复习前面的内容，首先通过VC创建一个ATLCOM的dll项目在项目上右键-->New Atl Object，输入接口名称，IDE会根据名称生成一个对应的接口，还是以MyString接口为例，完成这一步后，整个项目的类结构如下：这些全局函数的作用与之前的相同，它里面多了一个_Module的全局对象，该对象类似于MFC中的CWinApp类，它用来表示整个项目的实例，里面封装了对于引用计数的管理，以及对项目中各个接口注册信息的管理，所以看DllRegisterServer等函数就会发现它们里面其实很简单，大部分的工作都由_Module对象完成。整个IDL文件的定义如下：import "oaidl.idl"; import "ocidl.idl"; [ object, uuid(E3BD0C14-4D0C-48F2-8702-9F8DBC96E154), dual, helpstring("IMyString Interface"), pointer_default(unique) ] interface IMyString : IDispatch { }; [ uuid(A61AC54A-1B3D-4D8E-A679-00A89E2CBE93), version(1.0), helpstring("FirstAtlCom 1.0 Type Library") ] library FIRSTATLCOMLib { importlib("stdole32.tlb"); importlib("stdole2.tlb"); [ uuid(11CBC0BE-B2B7-4B5C-A186-3C30C08A7736), helpstring("MyString Class") ] coclass MyString { [default] interface IMyString; }; };里面的内容与上一次的内容相差无几，多了一个helpstring属性，该属性用于产生帮助信息，当使用者在调用接口函数时IDE会将此提示信息显示给调用者。由于有系统框架给我们做的大量的工作，我们再也不用关心像引用计数的问题，只需要将精力集中在编写接口的实现上，减少了不必要的工作量。至此从结构上说明了为了实现跨语言COM组件内部做了哪些工作，当然只有这些工作是肯定不够的，后面会继续说明它所做的另一块工作——提供的一堆通用的变量类型。

COM学习（二）——COM的注册和卸载 COM组件是跨语言的，组件被注册到注册表中，在加载时由加载函数在注册表中查找到对应模块的路径并进行相关加载。它的存储规则如下：在注册表的HKEY_CLASSES_ROOT中以模块名的方式保存着COM模块的GUID，比如HKEY_CLASSES_ROOT\ADODB.Error\CLSID键中保存着模块ADODB.Error的GUID为{00000541-0000-0010-8000-00AA006D2EA4}在HKEY_CLASSES_ROOT\CLSID中以GUID为项名保存着对应组件的详细信息，比如之前的{00000541-0000-0010-8000-00AA006D2EA4}这个GUID在注册表中的位置为HKEY_CLASSES_ROOT\CLSID\{00000541-0000-0010-8000-00AA006D2EA4}\InprocServer32\项的默认键中保存着模块所在路径为%CommonProgramFiles%\System\ado\msado15.dll一般的COM模块都是使用regsvr32程序注册到注册表中，该程序在注册时会在模块中查找DllRegisterServer函数，卸载时调用模块中提供的DllUnregisterServer，所以要实现注册的功能主要需要实现这两个函数这两个函数的原型如下：STDAPI DllRegisterServer(); STDAPI DllUnregisterServer();通过VS的F12功能查找STDAPI 的定义如下：#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE在查看STDAPICALLTYPE得到如下结果：#define STDAPICALLTYPE __stdcall所以这个宏展开也就是extern "C" HRESULT __stdcall DllRegisterServer();为了实现注册功能，首先定义一个全局的变量，用来表示需要写入到注册表中的项const TCHAR *g_regTable[][3] = { {_T("SOFTWARE\\ComDemo"), 0, _T("ComDemo")}, {_T("SOFTWARE\\ComDemo\\InporcServer32"), 0, (const TCHAR*)-1}这三项分别为注册表项，注册表项中的键名和键值，当键名为0时会创建一个默认的注册表键，最后一个-1我们会在程序中判断，如果键值为-1，那么值取为模块的路径下面是注册的函数STDAPI DllRegisterServer() { HKEY hKey = NULL; TCHAR szFileName[MAX_PATH] = _T(""); GetModuleFileName(g_hDllIns, szFileName, MAX_PATH); int nCount = sizeof(g_regTable) / sizeof(*g_regTable); for (int i = 0; i < nCount; i++) { LPCTSTR pszKeyName = g_regTable[i][0]; LPCTSTR pszValueName = g_regTable[i][1]; LPCTSTR pszValue = g_regTable[i][2]; if (pszValue == (const TCHAR*)-1) { pszValue = szFileName; } long err = RegCreateKey(HKEY_LOCAL_MACHINE, pszKeyName, &hKey); if (err != ERROR_SUCCESS) { return SELFREG_E_LAST; } err = RegSetValueEx(hKey, pszValueName, 0, REG_SZ, (const BYTE*)pszValue, _tcslen(pszValue) * sizeof(TCHAR)); if (err != ERROR) { return SELFREG_E_LAST; } RegCloseKey(hKey); } return S_OK; }在程序中会循环读取上述全局变量中的值，将值保存到注册表中，在上面的代码中有一句sizeof(g_regTable) / sizeof(*g_regTable);这个是算需要循环多少次，第一个sizeof得到的是这个二维数组的总大小。在C语言中我们说二维数组可以看做是由一维数组组成的，这个二维数组可以看成是由两个一维数组——一个由3个const TCHAR 成员组成的一维数组组成。所以g_regTab自然就是这个一维数组的首地址，第二个sizeof就是这个一维数组的大小，两个相除得到的就是一维数组的个数。卸载函数如下：STDAPI DllUnregisterServer() { int nCount = sizeof(g_regTable) / sizeof(*g_regTable); for (int i = nCount - 1; i >= 0; i--) { LPCTSTR pszKeyName = g_regTable[i][0]; long err = RegDeleteKey(HKEY_LOCAL_MACHINE, pszKeyName); if (err != ERROR_SUCCESS) { return SELFREG_E_LAST; } } return S_OK; }至此已经实现注册和卸载函数。后面就可以直接使用regsvr32这个程序进行注册和卸载了.

COM学习（一）——COM基础思想 概述学习微软技术COM是绕不开的一道坎，最近做项目的时候发现有许多功能需要用到COM中的内容，虽然只是简单的使用COM中封装好的内容，但是许多代码仍然只知其然，不知其所以然，所以我决定从头开始好好学习一下COM基础的内容，因此在这记录下自己学习的内容，以便日后参考，也给其他朋友提供一点学习思路。COM的全称是Component Object Module，组件对象模型。组件就我自己的理解就是将各个功能部分编写成可重用的模块，程序就好像搭积木一样由这些可重用模块构成，这样将各个模块的耦合降到最低，以后升级修改功能只需要修改某一个模块，这样就大大降低了维护程序的难度和成本，提高程序的可扩展性。COM是微软公司提出的组件标准，同时微软也定义了组件程序之间进行交互的标准，提供了组件程序运行所需的环境。COM是基于组件化编程的思想，在COM中每一个组件成为一个模块，它可以是动态链接库或者可执行文件，一个组件程序可以包含一个或者多个组件对象，COM对象不同于OOP(面向对象)中的对象，COM对象是定义在二进制机器代码基础之上，是跨语言的。而OOP中的对象是建立在语言之上的。脱离了语言对象也就不复存在.COM是独立在编程语言之上的，是语言无关的。COM的这一特性使得不同语言开发的组件之间的互相交互成为可能。COM对象和接口COM中的对象类似于C++中的对象，对象是某个类中的实例。而类则是一组相关的数据和功能组合在一起的一个定义。使用对象的应用(或另一个对象)称为客户，有时也称为对象的用户。 接口是一组逻辑相关的函数的集合，比如一组处理URL的接口，处理HTTP请求的接口等等。在习惯上接口通常是以"I"开头。对象通过接口成员函数为客户提供各种形式的服务。一个对象可以拥有多个不同的接口，以表现不同的功能集合。 在C++语言中，一个接口就是一个虚基类，而对象就是该接口的实现类，派生自该接口并实现接口的功能。class IBook { public: virtual void NextPage() = 0; virtual void ForwardPage() = 0; } class IAppliances { public: virtual void charge() = 0; virtual void shutdown() = 0; } class CKindle: public IBook, IAppliances { public: virtual void NextPage(); virtual void ForwardPage(); virtual void charge(); virtual void shutdown(); }就像上面的例子，上面的例子中提供了一个书本的接口，书本可以翻到上一页，下一页，而电器有充电和关机的接口，最后我们利用kindle这个类来实现这两个接口。所以在使用上我们可以利用下面的伪代码来使用pInterface = CreateInterface(ID_IBOOK, ID_KINDLE); pInterface->NextPage(); if(Late()) { pInter2 = pInterface->QueryInterface(ID_APPLIANCES); pInter2->shutdown(); }在平时我们使用kindle的翻页功能来看书，因为翻页功能在接口IBook，所以首先调用一个创建接口的函数，传入对应接口以及接口实现类的标识，用来生成相应的接口，其实在内部也就是根据类ID来创建一个对应的实现类的实例。然后根据需要转化为对应基类的指针。在看书看累的时候，将接口转化为电子产品的接口，调用对应的关机功能，关闭电子书。在之后比如说kindle进行了升级，也就是重写了实现这些接口的代码，但是接口原型不变，这样使用接口的代码不用改变，也就是说即使kindle对内部进行了升级，优化某些功能，用户在使用上仍然是那样在用，不必改变使用习惯。再比如kindle出了一个新款，提供了背光功能，这个时候可能提供一个新接口：class IAppliances2 : public IAppliances { public: virtual void Light() = 0; }然后只需要稍微更新一下CKindle这个实现类，新增一个Light接口的实现，在使用上如果不用背光功能原来的代码就够用了，如果要使用背光功能，只需要将原来的接口类型改为IAppliances2 ，并且添加调用背光功能的函数，而其余的功能也不变，这与实际生活相似，某个产品提供新功能时，一般保持原始功能的使用方法不变，新功能会有新的按钮或者其他方法进行打开。再比如说我不想用kindle了改用其他的电子阅读器，只要接口不变，我的使用方法基本不变，唯一改变的可能是我以前拿着kindle，现在拿着其他品牌的阅读器，也就是说可能要改变传入CreateInterface函数中的类标识。COM基本接口COM中所有接口都派生自该接口：struct IUnknown { virtual HRESULT QueryInterface(REFIID riid,void **ppvObject) = 0; virtual ULONG AddRef( void) = 0; virtual ULONG Release( void) = 0; };所有类都应该实现上述三个方法，AddRef主要将接口的引用计数+1， 而Release则是将引用计数 -1，当对象的引用计数为0，则会调用析构函数，释放对象的存储空间。每一次接口的创建和转化都会增加引用计数，而每次不再使用调用Release，都会把引用计数 -1，当引用计数为0时会释放对象的空间。QueryInterface主要用来进行接口转化，将对象的指针转化为另外一个接口的指针，就好像上面例子中pInter2 = pInterface->QueryInterface(ID_APPLIANCES);这句代码将之前的Ibook接口转化为电子产品的接口。在C++中也就是做了一次强制类型转化。对象和接口的唯一标识在COM中，对象本身对于客户来说是不可见的，客户请求服务时，只能通过接口进行。每一个接口都由一个128位的全局唯一标识符(GUID，Global Unique Identifier)来标识。客户通过GUID来获得接口的指针，再通过接口指针，客户就可以调用其相应的成员函数。与接口类似，每个组件也用一个 128 位 GUID 来标识，称为 CLSID(class identifer，类标识符或类 ID)，用 CLSID 标识对象可以保证(概率意义上)在全球范围内的唯一性。实际上，客户成功地创建对象后，它得到的是一个指向对象某个接口的指针，因为 COM 对象至少实现一个接口(没有接口的 COM 对象是没有意义的)，所以客户就可以调用该接口提供的所有服务。根据 COM 规范，一个 COM 对象如果实现了多个接口，则可以从某个接口得到该对象的任意其他接口。由此可看出，客户与 COM 对象只通过接口打交道，对象对于客户来说只是一组接口。在COM中GUID的定义如下：typedef struct _GUID { unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[ 8 ]; } GUID;一般我们在程序中只是作为一个标志来使用，并不对它进行特别的操作。生成它一般是使用VS自带的GUID生成工具。而CLSID的定义如下：typedef GUID CLSID;其实在COM中一般涉及到ID的都是GUID，只是利用typedef另外定义了一个名称而已另外COM也提供了一组函数用来对GUID进行操作：函数功能IsEqualGUID判断GUID是否相等IsEqualCLSID判断CLSID是否相等IsEqualIID判断IID是否相等CLSIDFromProgID把字符串形式的CLSID转化为CLSID结构形式（类似于将字符串的234转化为数字，也是把字面上的CLSID转化为计算机能识别的CLSID）StringFromCLSID把CLSID转化为字符串形式IIDFromString把字符串形式的IID转化为IID接口形式StringFromIID把IID结构转化为字符串StringFromGUID2把GUID形式转化为字符串形式COM接口的一般使用步骤一般使用COM中的时候首先使用CoInitialize初始化COM环境，不用的时候使用CoUninitialize卸载COM环境，在使用接口中一般需要进行下面的步骤调用CoCreateInstance函数传入对应的CLSID和对应的IID，生成对应对象并传入相应的接口指针。使用该指针进行相关操作调用接口的QueryInterface函数，转化为其他形式的接口在最后分别调用各个接口的Release函数，释放接口下面提供一个小例子，以供参考，也方便更好的理解COM//组件部分 extern "C" __declspec(dllexport) void __stdcall ComCreateObject(GUID clsID, GUID interfaceID, void** pObj); void __stdcall ComCreateObject(GUID clsID, GUID interfaceID, void** pObj) { if (clsID == CLSID_COMSTRING) { CComString *pComObject = new CComString; *pObj = pComObject->QueryInterface(interfaceID); } } class IComBase { public: virtual void* QueryInterface(GUID gInterfaceId) = 0; virtual void AddRef() = 0; virtual void Release() = 0; }; static const GUID IID_ICOMSTRING = { 0xb2fcd22c, 0x63fa, 0x4f61, { 0xbf, 0x12, 0xd3, 0xd2, 0x5a, 0x99, 0x59, 0x24 } }; class IComString : public IComBase { public: virtual void Init(LPCTSTR pStr) = 0; virtual int Find(LPCTSTR lpSubStr) = 0; virtual int GetLength() = 0; }; static const GUID CLSID_COMSTRING = { 0xf57f3489, 0xff2d, 0x4c97, { 0xb1, 0xf6, 0xc, 0x60, 0x7e, 0xf7, 0xae, 0xfc } }; class CComString : public IComString { public: virtual void* QueryInterface(GUID gInterfaceId); virtual void AddRef(); virtual void Release(); virtual void Init(LPCTSTR pStr); virtual int Find(LPCTSTR lpSubStr); virtual int GetLength(); protected: int m_nCnt = 0; CString m_csString; }; //cpp void* CComString::QueryInterface(GUID gInterfaceId) { if (gInterfaceId == IID_ICOMSTRING) { //该接口的引用计数+1 AddRef(); return dynamic_cast<IComString*>(this); } //如果它还实现了其他接口，可以再写判断，生成其他类型的接口 return NULL; } void CComString::AddRef() { m_nCnt++; } void CComString::Release() { m_nCnt--; //引用计数为0，此时没有该类的接口被使用，应该释放该类 if (m_nCnt == 0) { delete this; } } void CComString::Init(LPCTSTR pStr) { m_csString = pStr; } int CComString::Find(LPCTSTR lpSubStr) { return m_csString.Find(lpSubStr); } int CComString::GetLength() { return m_csString.GetLength(); }这些代码被封装在一个dll中，dll中导出一个函数ComCreateObject，外部在使用时调用该函数传入对应的ID，以便生成对应的接口。在这个dll里面提供一个接口的基类IComBase，这个是仿照了COM种的IUnknow基类，另外定义了一个IComString字符串的接口，同时定义了它的实现类CComString，为了简单，它的功能方法我直接使用了一个CString类实现。在函数ComCreateObject，会根据传入对应的类ID，来生成对应的类实例，然后调用实例的QueryInterface，转化成对应的接口，在实现类中实现了这个方法，实现类中的QueryInterface方法主要完成了类型转化并将引用计数+1。而Release函数在每次-1的时候会进行判断，当引用计数为0时销毁该类的实例由于类是new出来创建在堆上的，所以每次用完一定要记得调用Release释放，否则会造成内存泄露注意：在使用这里使用的是dynamic_cast进行类型转化，在进行类的强制类型转化时，特别是在有多重继承的情况下，最好使用dynamic_cast方式进行转化，当一个类拥有多个基类时，类中有多个虚函数表，为了能正常找到对应的虚函数表，就需要进行对应的偏移量的计算，C中的强制类型转化是直接将对象的首地址进行转化，这样在寻址虚函数表时可能会出错。而dynamic_cast会进行对应的计算。详细情形请参考这里在使用上void ComInitialize(); void ComUninitialize(); typedef void(__stdcall *pfnCreateInstance)(GUID, GUID, void**); pfnCreateInstance CreateInstance; HMODULE hComDll = NULL; int _tmain(int argc, _TCHAR* argv[]) { ComInitialize(); IComString *pIString = NULL; CreateInstance(CLSID_COMSTRING, IID_ICOMSTRING, (void**)&pIString); pIString->Init(_T("Hello World")); IComString* pIString2 = (IComString*)(pIString->QueryInterface(IID_ICOMSTRING)); int nLength = pIString2->GetLength(); int iPos = pIString2->Find(_T("World")); printf("%d, %d\n", nLength, iPos); pIString->Release(); pIString2->Release(); return 0; } void ComInitialize() { hComDll = LoadLibrary(_T("ComInterface.dll")); if (NULL != hComDll) { CreateInstance = (pfnCreateInstance)GetProcAddress(hComDll, "ComCreateObject"); } } void ComUninitialize() { FreeLibrary(hComDll); }给使用者使用时只需要提供对应类和接口的GUID，然后将函数ComCreateObject原型提供给调用者，以便生成对应的接口。这里为了模仿COM的使用定义了ComInitialize和ComUninitialize这两个函数，真实的初始化函数怎么写的，我也不知道，在这里只是为了模仿COM的使用。至此相信各位小伙伴应该对COM有了一个初步的了解

Vista 及后续版本的新线程池 在上一篇的博文中，说了下老版本的线程池，在Vista之后，微软重新设计了一套线程池机制，并引入一组新的线程池API，新版线程池相对于老版本的来说，它的可控性更高，它允许程序员自己定义线程池，并规定线程池中的线程数量和其他一些属性。线程池使用线程池的使用主要需要下面的四步：创建工作项提交工作项等待工作项完成清理工作项在前面说的四种线程池在使用上都是这4步，只是使用的API函数不同，每种线程池的每一步都有一个对应的API，总共有16个API普通线程池创建工作项的API为PTP_WORK WINAPI CreateThreadpoolWork( __in PTP_WORK_CALLBACK pfnwk, __inout_opt PVOID pv, __in_opt PTP_CALLBACK_ENVIRON pcbe );第一个参数是一个回调函数，当提交后，线程池中的线程会执行这个回调函数第二个参数是传递给回调函数的参数第三个参数是一个表示回调环境的结构，这个在后面会说回调函数的原型VOID CALLBACK WorkCallback( __inout PTP_CALLBACK_INSTANCE Instance, __inout_opt PVOID Context, __inout PTP_WORK Work );第一个参数用于表示线程池当前正在处理的一个工作项的实例，在后面会说它怎么用第二个参数是传给回调函数的参数的指针第三个参数是当前工作项的结构创建工作项完成之后调用SubmitThreadpoolWork将工作项提交到对应的线程池，由线程池中的线程处理这个工作项，该函数原型如下：VOID WINAPI SubmitThreadpoolWork( __inout PTP_WORK pwk );这个函数只有一个参数那就是工作项的指针，即我们想将哪个工作项提交。提交工作项之后，在需要同步的地方，调用函数WaitForThreadpoolWorkCallbacks,等待线程池中的工作项完成,该函数原型如下VOID WINAPI WaitForThreadpoolWorkCallbacks( __inout PTP_WORK pwk, __in BOOL fCancelPendingCallbacks );最后一个参数表示线程池是否需要执行未执行的工作项，注意它只能取消执行还没有开始执行的工作项，而不能取消已经有线程开始执行的工作项，最后调用函数CloseThreadpoolWork清理工作项，该函数的原型如下：VOID WINAPI CloseThreadpoolWork( __inout PTP_WORK pwk );就我个人的理解，TP_WORK应该保存的是一个工作项的信息，包含工作项的回调以及传递个回调函数的参数，每当提交一个工作项就是把这个结构放入到线程池的队列中，当线程池中有空闲线程的时候从队列中取出这个结构，将结构中的回调函数参数传递给回调函数，并调用它。我们可以重复提交同一个工作项多次，但是每个工作项一旦定义好了，那么传递给对应回调函数的参数应该是固定的，后期是没办法更改它的。它的等待函数调用时根据第二个参数，如果为TRUE则将线程池队列中的工作项清除，然后等待所有线程都为空闲状态时返回，而当参数为FALSE时，就不对队列中的工作项进行操作，并且一直等到线程池中的所有线程为空闲。下面是一个具体的使用例子：VOID CALLBACK MyWorkCallback( PTP_CALLBACK_INSTANCE Instance, PVOID Parameter, PTP_WORK Work ) { int nWaitTime = 4; printf("线程[%04x]将等待%ds\n", GetCurrentThreadId(), nWaitTime); Sleep(nWaitTime * 1000); printf("线程[%04x]执行完毕\n", GetCurrentThreadId()); } int _tmain(int argc, _TCHAR* argv[]) { PTP_WORK_CALLBACK workcallback = MyWorkCallback; PTP_WORK work = CreateThreadpoolWork(workcallback, NULL, NULL); //创建工作项 for (int i = 0; i < 4; i++) { SubmitThreadpoolWork(work); //提交工作项 } //等待线程池中的所有工作项完成 WaitForThreadpoolWorkCallbacks(work, FALSE); //关闭工作项 CloseThreadpoolWork(work); return 0; }定时器线程池定时器线程池中使用的对应的API分别为CreateThreadpoolTimer、SetThreadpoolTimer、WaitForThreadpoolTimerCallbacks和CloseThreadpoolTimer，这些函数的参数与之前的函数参数基本类似，区别比较大的是SetThreadpoolTimer，由于涉及到定时器，所以这里的参数稍微复杂一点VOID WINAPI SetThreadpoolTimer( __inout PTP_TIMER pti, __in_opt PFILETIME pftDueTime, __in DWORD msPeriod, __in_opt DWORD msWindowLength );第二个参数表示定时器触发的时间，它是一个64位的整数，如果为正数表示一个绝对的时间，表示从1960年到多少个100ns的时间后触发，如果为负数则表示从设置之时起经过多少时间后触发，单位为微秒（转化为秒是1000 * 1000）第三个参数每隔多长时间触发一次，如果只是想把这个定时器作为一次性的，和第四个参数没有用处，而如果想让线程池定期的触发它，这个值就是定期触发的间隔 时间，单位为毫秒第四个参数是用来给回调函数的执行时机增加一定的随机性，如果这个定时器是一个定期触发的定时器，那么这个值告诉线程池，可以在自定时器设置时间起，在(msPeriod - msWindowLength, mePeriod + msWindowsLong)这个区间之后的任意时间段触发另外我自己在编写测试代码的时候发现有的时候调用WaitForThreadpoolTimerCallbacks可能立即就返回了，后来我自己分析可能的原因是这个函数会在线程池队列中没有需要处理的工作项，并且线程池中线程为空闲的时候返回，当我使用定时器的时候，在等待时可能这个时候定时器上的时间未到，而线程池中又没有需要处理的定时器的工作项，所以它就返回了从而未达到等待的效果。下面是一个使用的具体例子,这个例子是《Windows核心编程》这本书中的例子，我觉得它里面有一个更改MessageBox显示信息的功能，所以将其修改了下作为例子int g_nWaitTime = 10; TCHAR g_szTitle[] = _T("提示"); #define ID_MSGBOX_STATIC_TEXT 0x0000ffff //MessageBox上内容部分的控件ID VOID CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_TIMER Timer) { HWND hWnd = FindWindow(NULL, g_szTitle); //找到MessageBox所对应的窗口句柄 if (NULL != hWnd) { TCHAR szText[1024] = _T(""); StringCchPrintf(szText, 1024, _T("您将有%ds的时间"), --g_nWaitTime); SetDlgItemText(hWnd, ID_MSGBOX_STATIC_TEXT, szText); //更改显示信息 } if (g_nWaitTime == 0) { ExitProcess(0); } } int _tmain(int argc, _TCHAR* argv[]) { //创建定时器历程 PTP_TIMER pTimer = CreateThreadpoolTimer(TimerCallback, NULL, NULL); //将定时器历程加入到线程池 ULARGE_INTEGER uDueTime = {0}; FILETIME FileDueTime = {0}; uDueTime.QuadPart = (LONGLONG) -(1 * 10 * 1000 * 1000); //时间为1s FileDueTime.dwHighDateTime = uDueTime.HighPart; FileDueTime.dwLowDateTime = uDueTime.LowPart; SetThreadpoolTimer(pTimer, &FileDueTime, 1000, 0); //每1s调用一次 WaitForThreadpoolTimerCallbacks(pTimer, FALSE); //此处调用等待函数会立即返回 TCHAR szText[] = _T("您将有10s的时间"); MessageBox(NULL, szText, g_szTitle, MB_OK); //关闭工作项 CloseThreadpoolTimer(pTimer); return 0; }同步对象线程池对这种线程池的使用主要调用这样几个函数: CreateThreadpoolWait、SetThreadpoolWait、WaitForThreadpoolWaitCallbacks、CloseThreadpoolWait ，这几个函数的使用与之前的普通线程池的使用类似，在这就不再进行说明直接给例子VOID CALLBACK WaitCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WAIT Wait, TP_WAIT_RESULT WaitResult) { if (WaitResult == WAIT_OBJECT_0) { printf("[%04x] wait the event\n", GetCurrentThreadId()); }else if (WaitResult == WAIT_TIMEOUT) { printf("[%04x] time out\n", GetCurrentThreadId()); } } int _tmain(int argc, _TCHAR* argv[]) { //创建等待线程池 PTP_WAIT pWait = CreateThreadpoolWait(WaitCallback, NULL, NULL); //创建事件 HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //等待时间为1s FILETIME ft = {0}; ULARGE_INTEGER uWaitTime = {0}; uWaitTime.QuadPart = (LONGLONG) - 1 * 1000 * 1000; ft.dwHighDateTime = uWaitTime.HighPart; ft.dwLowDateTime = uWaitTime.LowPart; for (int i = 0; i < 5; i++) { //模拟等待5次 SetThreadpoolWait(pWait, hEvent, &ft); Sleep(1000); //休眠 SetEvent(hEvent); } WaitForThreadpoolWaitCallbacks(pWait, FALSE); CloseThreadpoolWait(pWait); CloseHandle(hEvent); return 0; }这种类型的回调函数的WaitResult参数实际上是一个DWORD类型，表示调用这个回调的原因，WAIT_OBJECT_0表示同步对象变为有信号，WAIT_TIMEOUT表示超时WAIT_ABANDONED_0表示穿入的互斥量被遗弃（只有在同步对象为互斥量的时候才会有这种值）完成端口线程池完成端口线程池的使用主要用这些API：CreateThreadpoolIo、StartThreadpoolIo、WaitForThreadpoolIoCallbacks、CloseThreadpoolIo，这些函数的使用也是十分的简单，下面再次将之前的完成端口写日志的例子进行改写：int _tmain(int argc, _TCHAR* argv[]) { TCHAR szAppPath[MAX_PATH] = _T(""); GetAppPath(szAppPath); StringCchCat(szAppPath, MAX_PATH, _T("NewIocpLog.txt")); HANDLE hFile = CreateFile(szAppPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { return 0; } //创建IOCP线程池 g_pThreadpoolIO = CreateThreadpoolIo(hFile, IoCompletionCallback, hFile, NULL); StartThreadpoolIo(g_pThreadpoolIO); //写入Unicode字节码 LPIOCP_OVERLAPPED pIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); pIocpOverlapped->dwDataLen = sizeof(WORD); pIocpOverlapped->hFile = hFile; WORD dwUnicode = MAKEWORD(0xff, 0xfe); //构造Unicode前缀 pIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WORD)); CopyMemory(pIocpOverlapped->pData, &dwUnicode, sizeof(WORD)); //偏移文件指针 pIocpOverlapped->Overlapped.Offset = g_FilePointer.LowPart; pIocpOverlapped->Overlapped.OffsetHigh = g_FilePointer.HighPart; g_FilePointer.QuadPart += pIocpOverlapped->dwDataLen; //写文件 WriteFile(hFile, pIocpOverlapped->pData, pIocpOverlapped->dwDataLen, &pIocpOverlapped->dwWrittenLen, &pIocpOverlapped->Overlapped); //创建线程进行写日志操作 HANDLE hWrittenThreads[MAX_WRITE_THREAD]; for (int i = 0; i < MAX_WRITE_THREAD; i++) { hWrittenThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WriteThread, &hFile, 0, NULL); } //等待所有写线程执行完成 WaitForMultipleObjects(MAX_WRITE_THREAD, hWrittenThreads, TRUE, INFINITE); for (int i = 0; i < MAX_WRITE_THREAD; i++) { CloseHandle(hWrittenThreads[i]); } //等待线程池中待处理的IO完成请求 WaitForThreadpoolIoCallbacks(g_pThreadpoolIo, FALSE); CloseHandle(hFile); //关闭IOCP线程池 CloseThreadpoolIo(g_pThreadpoolIO); return 0; } VOID CALLBACK WriteThread(LPVOID lpParam) { TCHAR szBuf[255] = _T("线程[%04x]模拟写入一条日志记录\r\n"); TCHAR szWrittenBuf[255] = _T(""); StringCchPrintf(szWrittenBuf, 255, szBuf, GetCurrentThreadId()); for (int i = 0; i < EVERY_THREAD_WRITTEN; i++) { //提交一个IOCP历程 StartThreadpoolIo(g_pThreadpoolIO); LPIOCP_OVERLAPPED lpIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); size_t dwBufLen = 0; StringCchLength(szWrittenBuf, 255, &dwBufLen); lpIocpOverlapped->dwDataLen = dwBufLen * sizeof(TCHAR); lpIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwBufLen + 1) * sizeof(TCHAR)); CopyMemory(lpIocpOverlapped->pData, szWrittenBuf, dwBufLen * sizeof(TCHAR)); lpIocpOverlapped->hFile = *(HANDLE*)lpParam; //同步文件指针 *((LONGLONG*)&(lpIocpOverlapped->Overlapped.Pointer)) = InterlockedCompareExchange64(&g_FilePointer.QuadPart, g_FilePointer.QuadPart + lpIocpOverlapped->dwDataLen, g_FilePointer.QuadPart); //写文件 WriteFile(lpIocpOverlapped->hFile, lpIocpOverlapped->pData, lpIocpOverlapped->dwDataLen, &lpIocpOverlapped->dwWrittenLen, &lpIocpOverlapped->Overlapped); } } VOID CALLBACK IoCompletionCallback(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PVOID Overlapped,ULONG IoResult,ULONG_PTR NumberOfBytesTransferred,PTP_IO Io) { LPIOCP_OVERLAPPED pIOCPOverlapped = (LPIOCP_OVERLAPPED)Overlapped; //释放对应的内存空间 printf("线程[%04x]得到IO完成通知,写入长度%d\n", GetCurrentThreadId(), pIOCPOverlapped->dwDataLen); if (pIOCPOverlapped->pData != NULL) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped->pData); } if (NULL != pIOCPOverlapped) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped); pIOCPOverlapped = NULL; } }在新版的完成端口的线程池中，每当需要进行IO操作时，要保证在IO操作之前调用StartThreadpoolIo提交请求。如果没有那么我们的回调函数将不会被执行。注意：后面两种线程池与旧版的相比，最大的区别在于新版的是一次性的，也就是每提交一次，它只会执行一次，要想让其不停触发就需要不停的进行提交，而旧版的只需要绑定，一旦相应的事件发生，他就会不停地的执行线程池控制回调函数的终止操作线程池提供了一种便利的方法，用来描述当我们的回调函数返回之后，应该执行的一些操作，通过这种方式，可以通知其他线程，回调函数已经执行完毕。通过调用下面的一些API可以设置对应的同步对象，在线程池外的其他线程等待同步对象就可以知道什么时候回调执行完毕函数终止操作LeaveCriticalWhenCallbackReturns当回调函数返回时，线程池会自动调用LeaveCritical,并在参数中传入指定的CRITICAL_SECTION结构ReleaseMutexWhenCallbackReturns当回调函数返回时，线程池会自动调用ReleaseMutexWhen并在参数中传入指定的HANDLEReleaseSemaphoreWhenCallbackReturns当回调函数返回时，线程会自动调用ReleaseSemphore并在参数中传入指定的HANDLESetEventWhenCallbackReturns当回调函数返回时，线程会自动调用SetEvent,并在参数中传入指定的HANDLEFreeLibraryWhenCallbackReturns当回调函数返回时，线程会自动调用FreeLibrary并在参数中传入指定的HANDLE前4个函数给我们提供了一种方式来通知另外一个线程，回调函数调用完成，而最后一个函数则提供了一种在回调函数调用完成之时，清理动态库的方式，如果回调函数是在dll中实现的，但是在回调函数结束之时，我们希望卸载这个dll，这个时候不能调用FreeLibrary，这个时候回调函数虽然完成了任务，但是在后面还有函数栈平衡的操作，如果在返回时，我们将dll从内存中卸载，必然会导致最后的栈平衡操作访问非法内存，从而时应用程序崩溃。但是我们可以调用FreeLibraryWhenCallbackReturns，完成这个任务。下面是一个具体的例子：typedef struct tagWAIT_STRUCT { HANDLE hEvent; DWORD dwThreadId; }WAIT_STRUCT, *LPWAIT_STRUCT; WAIT_STRUCT g_waitStruct = {0}; VOID CALLBACK WorkCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work) { g_waitStruct.dwThreadId = GetCurrentThreadId(); Sleep(1000 * 10); SetEventWhenCallbackReturns(Instance, *(HANDLE*)&g_waitStruct); } int _tmain(int argc, _TCHAR* argv[]) { PTP_WORK pWork = CreateThreadpoolWork(WorkCallback, NULL, NULL); g_waitStruct.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); SubmitThreadpoolWork(pWork); WaitForSingleObject(g_waitStruct.hEvent, INFINITE); printf("线程池中线程[%04x]执行完成\n", g_waitStruct.dwThreadId); CloseThreadpoolWork(pWork); return 0; }上面的代码首先创建一个无信号的event对象，然后在回调函数中调用SetEventWhenCallbackReturns，当回调函数完成之时就会将event设置为有信号，这样我们在主线程中就可以等待，一旦回调函数执行完成，event变为有信号，wait函数就会返回。同时我们定义一个结构体尝试着从线程池中带出一个线程ID，并在主线程中使用它对线程池进行定制上面在讨论四种线程池的时候，使用的都是系统自带的线程池，这些线程池由系统管理，我们只能使用，而不能对它们的一些属性进行定制，但是新版本的线程池中提供了这样的方式，要对线程池进行定制，不能使用系统已经定义好的线程池，得自己定义，定义线程池使用API函数CreateThreadPool,这个函数只有一个参数，这个参数是Windows的保留参数目前应该赋值为NULL。该函数会返回一个PTP_POOL 类型的值，这个值是一个指针，用来标识一个线程池。创建完成之后，我们可以函数SetThreadpoolThreadMaximum 或者SetThreadpoolThreadMinimum来规定线程池中的最大和最小线程。当不需要自定义的线程池的时候可以使用函数CloseThreadPool，来清理自定义线程池。线程池的回调环境线程池的回调环境规定了回调函数的执行环境，比如由哪个线程池中的线程来调用，对应线程池的版本，对应的清理器和其他的属性等等。环境的结构定义如下：typedef struct _TP_CALLBACK_ENVIRON { TP_VERSION Version; //线程池的版本 PTP_POOL Pool; //关联的线程池 PTP_CLEANUP_GROUP CleanupGroup; //对应的环境清理组 PTP_CLEANUP_GROUP_CANCEL_CALLBACK CleanupGroupCancelCallback; PVOID RaceDll; struct _ACTIVATION_CONTEXT *ActivationContext; PTP_SIMPLE_CALLBACK FinalizationCallback; union { DWORD Flags; struct { DWORD LongFunction : 1; DWORD Private : 31; } s; } u; } TP_CALLBACK_ENVIRON, *PTP_CALLBACK_ENVIRON;虽然这个结构微软对外公布，而且是可以在程序中直接使用的，但是最好不要这么做，我们应该使用它提供的API对其进行操作，首先可以调用InitializeThreadpoolEnvironment来创建一个对应的回调环境，对我们传入的TP_CALLBACK_ENVIRON变量进行初始化。然后可以调用函数SetThreadpoolCallbackPool来规定由哪个线程池来调用对应的回调函数，如果将参数ptpp传入NULL,则使用系统默认的线程池。另外还可以调用SetThreadpoolCallbackRunsLong 来告诉线程池，我们的任务需要较长的时间来执行。最后当我们不需要这个回调环境的时候可以使用函数DestroyThreadpoolEnvironment来清理这个结构。我自己在看这一块的时候很长时间都转不过弯来，总觉得回调环境是由线程池持有的，每个线程池都有自己的回调环境，其实这个是错误的，既然它叫做回调环境，自然与线程池无关，它是用来控制回调行为的。当我们在创建对应的任务时，最后一个参数就是回调环境的指针，在提交任务时会首先将任务提交到回调环境所规定的线程池中，由对应的线程池来处理。函数SetThreadpoolCallbackPool从表面意思来看是未线程池设置一个回调环境其实这个意思正好相反，是为某个回调指定对应调用的线程池。在后面就可以看到，回调环境可比线程池大的多线程池的清理组为了得体的销毁自定义的线程池（系统自定义线程池不会被销毁），我们需要知道系线程池中各个任务何时完成，只有当所有任务都完成时销毁线程池才算得体的销毁，只有这样才能顺利的清理相关资源。但是由于线程池中的各项任务可能由不同的线程提交，提交的时机，任务执行完所需要的时间各不相同，所以基本上不可能知道线程池中的任务何时完成。为了解决这个问题，新版的线程池提供了清理组的概念。TP_CALLBACK_ENVIRON结构的PTP_CLEANUP_GROUP就为对应的执行环境绑定了一个清理组。当线程池中的任务都处理完成时能够得体的清理线程池可以调用CreateThreadpoolCleanupGroup来创建一个清理组，然后调用SetThreadpoolCallbackCleanupGroup来将线程池与对应的清理组。它的原型如下：VOID SetThreadpoolCallbackCleanupGroup( __inout PTP_CALLBACK_ENVIRON pcbe, __in PTP_CLEANUP_GROUP ptpcg, __in_opt PTP_CLEANUP_GROUP_CANCEL_CALLBACK pfng );第一个参数是一个回调环境第二个参数是一个对应的清理组，这两个参数就将对应的回调环境和清理组关联起来第三个参数是一个回调函数，每当一个工作项被取消，这个函数将会被调用。对应的回调函数的原型如下:VOID NTAPI CleanupGroupCancelCallback(PVOID pvObjectContext, PVOID CleanupContext);每当创建一个任务时，如果最后一个参数不为NULL，那么对应的清理组中会增加一项，表示又增加一个需要潜在清理的任务。最后我们调用对应的清理工作项的函数时，相当于显示的将需要清理的项从对应的清理组中去除。当我们的应用程序想要销毁线程池时，调用函数CloseThreadpoolCleanupGroupMembers。这个函数相比于之前的WaitForThreadpoolTimerCallbacks来说，它可以等待线程池中的所有工作项，而不管工作项是哪种类型，而对应的wait函数只能等待对应类型的工作项。VOID WINAPI CloseThreadpoolCleanupGroupMembers( __inout PTP_CLEANUP_GROUP ptpcg, __in BOOL fCancelPendingCallbacks, __inout_opt PVOID pvCleanupContext );CloseThreadpoolCleanupGroupMembers函数的第二个参数也是一个BOOL类型，它的作用与对应的wait函数中第二个参数的作用相同。如果第二个参数设置为NULL，那么每当该函数取消一个工作项，对应的PTP_CLEANUP_GROUP_CANCEL_CALLBACK 类型的回调就要被调用一次CleanupGroupCancelCallback函数中第一个参数是被取消项的上下文，这个上下文是由对应的创建工作项的函数的pvContext参数传递进来的，而第二个参数是由CloseThreadpoolCleanupGroupMembers函数的第三个参数传递进来的。当所有的工作项被取消后调用CloseThreadpoolCleanupGroup来释放清理组所占的资源。最后调用DestroyThreadpoolEnviroment和CloseThreadPool这样就可以得体的关闭线程池下面是使用的一个例子:VOID NTAPI CleanupGroupCancelCallback(PVOID pvObjectContext, PVOID CleanupContext) { printf("有任务[%d][%d]被取消\n", *(int*)pvObjectContext, *(int*)CleanupContext); } VOID CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_TIMER Timer) { Sleep(1000); printf("有对应的定时器历程被调用\n"); } int _tmain(int argc, _TCHAR* argv[]) { TP_CALLBACK_ENVIRON environ = {0}; //创建回调环境 InitializeThreadpoolEnvironment(&environ); PTP_CLEANUP_GROUP pCleanUp = CreateThreadpoolCleanupGroup(); //创建清理组 PTP_POOL pool = CreateThreadpool(NULL); //创建自定义线程池 //设置线程池中的最大、最小线程数 SetThreadpoolThreadMinimum(pool, 2); SetThreadpoolThreadMaximum(pool, 8); //设置对应的回调环境和清理组 SetThreadpoolCallbackPool(&environ, pool); SetThreadpoolCallbackCleanupGroup(&environ, pCleanUp, CleanupGroupCancelCallback); //创建对应的工作项 int i = 1; PTP_TIMER pTimerWork = CreateThreadpoolTimer(TimerCallback, &i, &environ); ULARGE_INTEGER uDueTime = {0}; FILETIME ft = {0}; uDueTime.QuadPart = (LONGLONG) - 10 * 1000 *1000; //设置时间为10s ft.dwHighDateTime = uDueTime.HighPart; ft.dwLowDateTime = uDueTime.LowPart; SetThreadpoolTimer(pTimerWork, &ft, 10 * 1000, 0); //休眠1s保证定时器历程被提交 Sleep(1000); int j = 2; //等待所有历程执行完成，并清理资源 CloseThreadpoolCleanupGroupMembers(pCleanUp, TRUE, &j); CloseThreadpoolCleanupGroup(pCleanUp); DestroyThreadpoolEnvironment(&environ); CloseThreadpool(pool); return 0; }上面的例子中，首先定义了一个回调环境并进行初始化，然后定义自定义线程和对应的清理环境，并将他们绑定。并且在定义清理器时指定对应的回调函数。接着又定义了一个定时器线程并给一个上下文。然后提交这个定时器历程。为了保证能顺利提交，在主程序中等待1s。最后我们直接取消它，由于定时器触发的时间为10s这个时候肯定还没有执行，而根据之前说的，当我们取消一个已提交但是未执行的工作项时会调用对应的清理组规定的回调，这个时候CleanupGroupCancelCallback会被调用。它的参数的值分别由CreateThreadpoolTimer和CloseThreadpoolCleanupGroupMembers给出，所以最终输出结果如下：自定义线程池可以很方便的控制它的行为。但是为了要得体的清理它所以得加上一个清理组，最终当我们使用自定义线程池时，基本步骤如下：调用函数InitializeThreadpoolEnvironment初始化一个回调环境调用CreateThreadpoolCleanupGroup创建一个清理组，并根据需要给出对应的清理回调调用CreateThreadpool创建自定义线程池调用对应的函数，设置自定义线程池的相关属性调用函数SetThreadpoolCallbackPool将线程池与回调环境绑定调用函数SetThreadpoolCallbackCleanupGroup将回调环境与对应的清理组绑定调用对应的函数创建工作项，并提交调用函数CloseThreadpoolCleanupGroupMembers等待清理组中的所有工作项被执行完或者被取消调用CloseThreadpoolCleanupGroup关闭清理组并释放资源调用DestroyThreadpoolEnvironment清理回调环境调用CloseThreadpool函数关闭自定义的线程池使用清理组的方式清理工作项相比于调用对应的close函数清理工作项来说，显得更方便，一来自定义线程池中工作项的种类繁多，每个工作项都调用一个Close函数显得太复杂，而且当工作项过多时，不知道何时哪个工作项执行完，这个时候如果强行调用函数关闭工作项，显得有点暴力，所以用工作组的方式更为优雅一些

老版VC++线程池 在一般的设计中，当需要一个线程时，就创建一个，但是当线程过多时可能会影响系统的整体效率，这个性能的下降主要体现在：当线程过多时在线程间来回切换需要花费时间，而频繁的创建和销毁线程也需要花费额外的机器指令，同时在某些时候极少数线程可能就可以处理大量，比如http服务器可能只需要几个线程就可以处理用户发出的http请求，毕竟相对于用户需要长时间来阅读网页来说，CPU只是找到对应位置的页面返回即可。在这种情况下为每个用户连接创建一个线程长时间等待再次处理用户请求肯定是不划算的。为了解决这种问题，提出了线程池的概念，线程池中保存一定数量的 线程，当需要时，由线程池中的某一个线程来调用对应的处理函数。通过控制线程数量从而减少了CPU的线程切换，而且用完的线程还到线程池而不是销毁，下一次再用时直接从池中取，在某种程度上减少了线程创建与销毁的消耗，从而提高效率在Windows上，使用线程池十分简单，它将线程池做为一个整体，当需要使用池中的线程时，只需要定义对应的回调函数，然后调用API将回调函数进行提交，系统自带的线程池就会自动执行对应的回调函数。从而实现任务的执行，这种方式相对于传统的VC线程来说，程序员不再需要关注线程的创建与销毁，以及线程的调度问题，这些统一由系统完成，只需要将精力集中到逻辑处理的回调函数中来，这样将程序员从繁杂的线程控制中解放出来。同时Windows中线程池一般具有动态调整线程数量的自主行为，它会根据线程中执行任务的工作量来自动调整线程数，即不让大量线程处于闲置状态，也不会因为线程过少而有大量任务处于等待状态。在windows上主要有四种线程池普通线程池同步对象等待线程池定时器回调线程池完成端口回调线程池这些线程池最大的特点是需要提供一个由线程池中线程调用的回调函数，当条件满足时回调函数就会被线程池中的对应线程进行调用。从设计的角度来说,这样的设计大大简化了应用程序考虑多线程设计时的难度,此时只需要考虑回调函数中的处理逻辑和被调用的条件即可,而不必考虑线程的创建销毁等等问题(一些设计还可以绕开繁琐的同步处理)。需要注意的就是一般不要在这些回调函数中设计处理类似UI消息循环那样的循环,即不要长久占用线程池中的线程。下面来依次说明各种线程池的使用：普通线程池普通线程池在使用时主要是调用QueueUserWorkItem函数将回调函数加入线程池队列，线程池中一旦有空闲的线程就会调用这个回调，函数原型如下：BOOL WINAPI QueueUserWorkItem( __in LPTHREAD_START_ROUTINE Function, __in_opt PVOID Context, __in ULONG Flags );第一个参数是一个回调函数地址，函数原型与线程函数原型相同，所以在设计时可以考虑使用宏开关来指定这个回调函数作为线程函数还是作为线程池的回调函数第二个参数是传给回调函数的参数指针第三个参数是一个标志值，它的主要值及其含义如下：标志含义WT_EXECUTEDEFAULT线程池的默认标志WT_EXECUTEINIOTHREAD以IO可警告状态运行线程回调函数WT_EXECUTEINPERSISTENTTHREAD该线程将一直运行而不会终止WT_EXECUTELONGFUNCTION执行一个运行时间较长的任务(这会使系统考虑是否在线程池中创建新的线程)WT_TRANSFER_IMPERSONATION以当前的访问字串运行线程并调用回调函数下面是一个具体的例子:void CALLBACK ThreadProc(LPVOID lpParam); int _tmain(int argc, _TCHAR* argv[]) { int nWaitTime; while (TRUE) { printf("请输入线程等待事件:"); scanf_s("%d", &nWaitTime); printf("\n"); if (0 == nWaitTime) { break; } //将任务放入到队列中进行排队 QueueUserWorkItem((LPTHREAD_START_ROUTINE)ThreadProc, &nWaitTime, WT_EXECUTELONGFUNCTION); } //结束主线程 printf("主线程[%04x]\n", GetCurrentThreadId()); return 0; } void CALLBACK ThreadProc(LPVOID lpParam) { int nWaitTime = *(int*)lpParam; printf("线程[%04x]将等待%ds\n", GetCurrentThreadId(), nWaitTime); Sleep(nWaitTime * 1000); printf("线程[%04x]执行完毕\n", GetCurrentThreadId()); }这段代码上我们加入了WT_EXECUTELONGFUNCTION标识，其实在计算机中，只要达到毫秒级的，这个时候已经达到了系统进行线程切换的时间粒度，这个时候它就是一个需要长时间执行的任务定时器回调线程池定时器回调主要经过下面几步：调用CreateTimerQueue:创建定时器回调的队列调用CreateTimerQueueTimer创建一个指定时间周期的计时器对象，并指定对应的回调函数及参数之后当指定的时间片到达，就会将对应的回调历程放入到队列中，一旦线程池中有空闲的线程就执行它另外可以调用对应的函数对其进行相关的操作：可以调用ChangeTimerQueueTimer修改一个已有的计时器对象的计时周期调用DeleteTimerQueueTimer删除一个计时器对象调用DeleteTimerQueue删除这样一个线程池对象，在删除这个线程池的时候它上面绑定的回调也会被删除，所以在编码时可以直接删除线程池对象而不用调用DeleteTimerQueueTimer删除每一个绑定的计时器对象。但是为了编码的完整性，最好加上删除计时器对象的操作下面是一个使用的具体例子VOID CALLBACK TimerCallback(PVOID lpParameter, BOOLEAN TimerOrWaitFired); int _tmain(int argc, _TCHAR* argv[]) { HANDLE hTimeQueue = CreateTimerQueue(); HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); HANDLE hTimer; CreateTimerQueueTimer(&hTimer, hTimeQueue, (WAITORTIMERCALLBACK)TimerCallback, &hEvent, 10000, 0, WT_EXECUTEDEFAULT); //等待定时器历程被调用 WaitForSingleObject(hEvent, INFINITE); //关闭事件对象 CloseHandle(hEvent); //删除定时器与定时器线程池的绑定 DeleteTimerQueueTimer(hTimeQueue, hTimer, NULL); //删除定时器线程池 DeleteTimerQueue(hTimeQueue); return 0; } VOID CALLBACK TimerCallback(PVOID lpParameter, BOOLEAN TimerOrWaitFired) { HANDLE hEvent = *(HANDLE*)lpParameter; if (TimerOrWaitFired) { printf("定时器回调历程[%04x]被执行\n", GetCurrentThreadId()); } SetEvent(hEvent); }上述的代码中我们定义了一个同步事件对象，这个事件对象将在定时器历程中设置为有信号，这样方便我们在主线程中等待计时器历程执行完成同步对象等待线程池使用同步对象等待线程池只需要调用函数RegisterWaitForSingalObject，将一个同步对象绑定，当这个同步对象变为有信号或者等待的时间到达时，会调用对应的回调历程。该函数原型如下：BOOL WINAPI RegisterWaitForSingleObject( __out PHANDLE phNewWaitObject, __in HANDLE hObject, __in WAITORTIMERCALLBACK Callback, __in_opt PVOID Context, __in ULONG dwMilliseconds, __in ULONG dwFlags ); 第一个参数是一个输出参数，返回一个等待对象的句柄，我们可以将其看做这个线程池的句柄第二个参数是一个同步对象第三个参数是对应的回调函数第四个参数是传入到回调函数中的参数指针第五个参数是等待的时间第六个参数是一个标志与函数QueueUserWorkItem中的标识含义相同对应回调函数的原型如下：VOID CALLBACK WaitOrTimerCallback( __in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired );当同步对象变为有信号或者等待的时间到达时都会调用这个回调，它的第二个参数就表示它所等待的对象是否为有信号。下面是一个使用的例子void WaitEventCallBackProc(PVOID lpParameter, BOOLEAN TimerOrWaitFired); int _tmain(int argc, _TCHAR* argv[]) { HANDLE hWait; HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //注册等待同步对象的线程池 RegisterWaitForSingleObject(&hWait, hEvent, (WAITORTIMERCALLBACK)WaitEventCallBackProc, NULL, 5000, WT_EXECUTELONGFUNCTION); for(int i = 0; i < 5; i++) { SetEvent(hEvent); Sleep(5000); } UnregisterWaitEx(hWait, hEvent); CloseHandle(hEvent); CloseHandle(hWait); return 0; } void WaitEventCallBackProc(PVOID lpParameter, BOOLEAN TimerOrWaitFired) { if (TimerOrWaitFired) { printf("线程[%04x]等到事件对象\n"); }else { printf("线程[%04x]等待事件对象超时\n"); } }完成端口线程池在前面讲述文件操作的博文中，讲解了在文件中完成端口的使用，其实完成端口本质上就是一个线程池，或者说，windows上自带的线程池是使用完成端口的基础之上编写的。所以在这，完成端口线程池的使用将比IO完成端口来的简单通过调用BindIoCompletionCallback函数来将一个IO对象句柄与对应的完成历程绑定，这样在对应的IO操作完成后，对应的历程将会被丢到线程池中准备执行相比于前面的文件中的完成端口，这个完成端口线程池要简单许多，文件的完成端口需要自己创建完成多个线程，创建完成端口，并且将线程与完成端口绑定。另外还需要在线程中调用相应的等待函数等待IO操作完成，而线程池则不需要这些操作，我只需要准备一个完成历程，然后调用BindIoCompletionCallback，这样一旦历程被调用，就可以肯定IO操作一定完成了。这样我们只需要将主要精力集中在完成历程的编写中函数BindIoCompletionCallback的原型如下：BOOL WINAPI BindIoCompletionCallback( __in HANDLE FileHandle, __in LPOVERLAPPED_COMPLETION_ROUTINE Function, __in ULONG Flags );第一个参数是一个对应IO操作的句柄第二个参数是对应的完成历程函数指针第三个参数是一个标志，与之前的标识相同完成历程的函数原型如下：VOID CALLBACK FileIOCompletionRoutine( __in DWORD dwErrorCode, __in DWORD dwNumberOfBytesTransfered, __in LPOVERLAPPED lpOverlapped );第一个参数是一个错误码，当IO操作发生错误时可以通过这个参数获取当前错误原因第二个参数是当前IO操作操作的字节数第三个参数是一个OVERLAPPED结构这函数的使用与之前文件完成端口中完成历程一样下面我们将之前文件完成端口的例子进行改写，如下：typedef struct tagIOCP_OVERLAPPED { OVERLAPPED Overlapped; HANDLE hFile; //操作的文件句柄 DWORD dwDataLen; //当前操作数据的长度 LPVOID pData; //操作数据的指针 DWORD dwWrittenLen; //写入文件中的数据长度 }IOCP_OVERLAPPED, *LPIOCP_OVERLAPPED; #define MAX_WRITE_THREAD 20 //写线程总数 #define EVERY_THREAD_WRITTEN 100 //每个线程写入信息数 LARGE_INTEGER g_FilePointer; //全局的文件指针 void GetAppPath(LPTSTR lpAppPath) { TCHAR szExePath[MAX_PATH] = _T(""); GetModuleFileName(NULL, szExePath, MAX_PATH); size_t nPathLen = 0; StringCchLength(szExePath, MAX_PATH, &nPathLen); for (int i = nPathLen; i > 0; i--) { if (szExePath[i] == _T('\\')) { szExePath[i + 1] = _T('\0'); break; } } StringCchCopy(lpAppPath, MAX_PATH, szExePath); } VOID CALLBACK WriteThread(LPVOID lpParam); VOID CALLBACK FileIOCompletionRoutine(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped); int _tmain(int argc, _TCHAR* argv[]) { TCHAR szAppPath[MAX_PATH] = _T(""); GetAppPath(szAppPath); StringCchCat(szAppPath, MAX_PATH, _T("IocpLog.txt")); HANDLE hFile = CreateFile(szAppPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { return 0; } //绑定IO完成端口 BindIoCompletionCallback(hFile, (LPOVERLAPPED_COMPLETION_ROUTINE)FileIOCompletionRoutine, 0); //往日志文件中写入Unicode前缀 LPIOCP_OVERLAPPED pIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); pIocpOverlapped->dwDataLen = sizeof(WORD); pIocpOverlapped->hFile = hFile; WORD dwUnicode = MAKEWORD(0xff, 0xfe); //构造Unicode前缀 pIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WORD)); CopyMemory(pIocpOverlapped->pData, &dwUnicode, sizeof(WORD)); //偏移文件指针 pIocpOverlapped->Overlapped.Offset = g_FilePointer.LowPart; pIocpOverlapped->Overlapped.OffsetHigh = g_FilePointer.HighPart; g_FilePointer.QuadPart += pIocpOverlapped->dwDataLen; //写文件 WriteFile(hFile, pIocpOverlapped->pData, pIocpOverlapped->dwDataLen, &pIocpOverlapped->dwWrittenLen, &pIocpOverlapped->Overlapped); //创建线程进行写日志操作 HANDLE hWrittenThreads[MAX_WRITE_THREAD]; for (int i = 0; i < MAX_WRITE_THREAD; i++) { hWrittenThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WriteThread, &hFile, 0, NULL); } //等待所有写线程执行完成 WaitForMultipleObjects(MAX_WRITE_THREAD, hWrittenThreads, TRUE, INFINITE); for (int i = 0; i < MAX_WRITE_THREAD; i++) { CloseHandle(hWrittenThreads[i]); } CloseHandle(hFile); return 0; } VOID CALLBACK FileIOCompletionRoutine(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped) { LPIOCP_OVERLAPPED pIOCPOverlapped = (LPIOCP_OVERLAPPED)lpOverlapped; //释放对应的内存空间 printf("线程[%04x]得到IO完成通知,写入长度%d\n", GetCurrentThreadId(), pIOCPOverlapped->dwDataLen); if (pIOCPOverlapped->pData != NULL) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped->pData); } if (NULL != pIOCPOverlapped) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped); pIOCPOverlapped = NULL; } } VOID CALLBACK WriteThread(LPVOID lpParam) { TCHAR szBuf[255] = _T("线程[%04x]模拟写入一条日志记录\r\n"); TCHAR szWrittenBuf[255] = _T(""); StringCchPrintf(szWrittenBuf, 255, szBuf, GetCurrentThreadId()); for (int i = 0; i < EVERY_THREAD_WRITTEN; i++) { LPIOCP_OVERLAPPED lpIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); size_t dwBufLen = 0; StringCchLength(szWrittenBuf, 255, &dwBufLen); lpIocpOverlapped->dwDataLen = dwBufLen * sizeof(TCHAR); lpIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwBufLen + 1) * sizeof(TCHAR)); CopyMemory(lpIocpOverlapped->pData, szWrittenBuf, dwBufLen * sizeof(TCHAR)); lpIocpOverlapped->hFile = *(HANDLE*)lpParam; //同步文件指针 *((LONGLONG*)&(lpIocpOverlapped->Overlapped.Pointer)) = InterlockedCompareExchange64(&g_FilePointer.QuadPart, g_FilePointer.QuadPart + lpIocpOverlapped->dwDataLen, g_FilePointer.QuadPart); //写文件 WriteFile(lpIocpOverlapped->hFile, lpIocpOverlapped->pData, lpIocpOverlapped->dwDataLen, &lpIocpOverlapped->dwWrittenLen, &lpIocpOverlapped->Overlapped); } }