update

Author: selfboot

Algorithm/Partition.md

@@ -11,7 +11,7 @@ C/C++编译系统将一个程序转化为可执行程序的过程包含：
 
 # 预处理
 
-预处理器是在程序源文件被编译之前根据预处理指令对程序源文件进行处理的程序。预处理器指令以#号开头标识，末尾不包含分号。预处理命令不是C/C++语言本身的组成部分，不能直接对它们进行编译和链接。C/C++语言的一个重要功能是可以使用预处理指令和具有预处理的功能。C/C++提供的预处理功能主要有文件包含、宏替换、条件编译等。
+预处理器是在程序源文件被编译之前根据预处理指令对程序源文件进行处理的程序。**预处理器指令以#号开头标识，末尾不包含分号**。预处理命令不是C/C++语言本身的组成部分，不能直接对它们进行编译和链接。C/C++语言的一个重要功能是可以使用预处理指令和具有预处理的功能。C/C++提供的预处理功能主要有文件包含、宏替换、条件编译等。
 
 ## 文件包含
 
@@ -124,7 +124,8 @@ helloworld.cpp 的源代码，仅仅有六行，而且该程序除了显示一
     hello, world
 
 
-参考  
+# 更多阅读
+  
 [详解C/C++预处理器](http://blog.csdn.net/huang_xw/article/details/7648117)  
 [Compiling Cpp](http://wiki.ubuntu.org.cn/Compiling_Cpp)  
 [C++静态库与动态库](http://www.cnblogs.com/skynet/p/3372855.html)  

C++/Compiler.md

@@ -20,7 +20,9 @@ const只是在`编译期的保护`，编译期会检查const变量有没有被
 
 # static
 
-《C和指针》中说static有两层含义：`指明存储属性；改变链接属性`。（1）全局变量（包括函数）加上static关键字后，链接属性变为internal，也就是将他们限定在了本作用域内；（2）局部变量加上static关键字后，存储属性变为静态存储，不存储在栈区，下一次将保持上一次的尾值。C 面向过程程序设计中的static：
+《C和指针》中说static有两层含义：`指明存储属性；改变链接属性`。（1）全局变量（包括函数）加上static关键字后，链接属性变为internal，也就是将他们限定在了本作用域内；（2）局部变量加上static关键字后，存储属性变为静态存储，不存储在栈区，下一次将保持上一次的尾值。
+
+C 面向过程程序设计中的static：
 
 1. 静态局部变量。在函数体内，一个被声明为静态的变量在这一函数被调用过程中维持上一次的值不变，即只初始化一次（该变量存放在.bss 或者 .data 区，而不是栈区）。
 2. 静态全局变量。在模块内（但在函数体外），一个被声明为静态的变量可以被模块内函数访问，但不能被模块外访问。（注：模块可以理解为文件）。这样其它文件中可以定义相同名字的变量，不会发生冲突。
@@ -171,7 +173,7 @@ c++ 11 中也可以使用关键字 using 来进行类型别名的声明，上面
 
 # register
 
-一般情况下，变量的值是存放在内存中的。当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到CPU中的运算器。经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放。
+一般情况下，变量的值是存放在内存中的。当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到CPU中的运算器。经过运算器进行运算，如果需要存储，再从运算器将数据送到内存存放。
 
 为提高执行效率，C++允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。这种变量叫做寄存器变量，用关键字register作声明。
 
@@ -182,7 +184,7 @@ c++ 11 中也可以使用关键字 using 来进行类型别名的声明，上面
        return f;
     }
 
-定义f和i是存放在寄存器的局部变量，如果n的值大，则能节约许多执行时间。不过要注意在程序中定义寄存器变量对编译系统只是建议性(而不是强制性)的。此外，现在的优化编译系统能够识别使用频繁的变量，自动地将这些变量放在寄存器中。
+定义f和i是存放在寄存器的局部变量，如果n的值大，则能节约许多执行时间。不过要注意在程序中**定义寄存器变量对编译系统只是建议性(而不是强制性)的**。此外，现在的优化编译系统能够识别使用频繁的变量，自动地将这些变量放在寄存器中。
 
 # explicit
 
@@ -240,17 +242,38 @@ int main()
 
 # final
 
-final关键字可用于修饰类、变量和方法。final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量不可被修改，一旦获得初始值，该变量就不能被重新赋值。
-    
-    class NoDerived final  { /* */ };
-    class Base { /* */ };               // Base 必须定义后才能作为基类
-    class Last final: Base { /* */ };
-    class Bad: Last  { /* */ };         // 错误，Last 是 final的
-    class Bad_2: NoDerived { /* */ };   // 错误，NoDerived 是 final的
+C++ 11 中引入了final关键字
+
+> Specifies that a virtual function cannot be overridden in a derived class or that a class cannot be inherited from.
+
+看一个简单的例子：
+
+```c++
+struct Base
+{
+    virtual void foo();
+};
+ 
+struct A : Base
+{
+    virtual void foo() final; // A::foo is final
+    void bar() final; // Error: non-virtual function cannot be final
+};
+ 
+struct B final : A // struct B is final
+{
+    void foo(); // Error: foo cannot be overridden as it's final in A
+};
+ 
+struct C : B // Error: B is final
+{
+};
+```
 
 ［[final 描述错误](http://www.nowcoder.com/questionTerminal/8272c92814ca40c39f9a534485c90be2)］
 
-# 更多阅读
+# 更多阅读
+
 [Meaning of “const” last in a C++ method declaration?](http://stackoverflow.com/questions/751681/meaning-of-const-last-in-a-c-method-declaration)  
 [Type aliases (typedef / using)](http://www.cplusplus.com/doc/tutorial/other_data_types/)   
 [How do I use extern to share variables between source files in C?](http://stackoverflow.com/questions/1433204/how-do-i-use-extern-to-share-variables-between-source-files-in-c)  

C++/Keywords.md

@@ -1,6 +1,6 @@
 /*
  * @Author: [email protected]
- * @Last Modified time: 2016-04-25 11:45:30
+ * @Last Modified time: 2016-08-28 11:11:10
  */
 
 #include <unistd.h>
@@ -39,9 +39,10 @@ int main()
     else if(pid>0)          // 父进程
     {
         close(pipe_fd[0]);  // 关闭读端
-        strcpy(w_buf,"1111222233334444\n");
-        if(write(pipe_fd[1],w_buf,16)!=-1){
-            printf("Write data %s", w_buf);
+        const char* content = "1111222233334444";
+        strncpy(w_buf, content, strlen(content));
+        if(write(pipe_fd[1],w_buf, strlen(content))!=-1){
+            printf("Write data %s\n", w_buf);
             printf("Parent write over\n");
         }
         close(pipe_fd[1]);  // 关闭写端

Coding/Linux_OS_Pipe.cpp

@@ -0,0 +1,31 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-08-28 16:42:20
+ */
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <cstdlib>
+#include <unistd.h>
+const int SIZE = 4;
+
+int main(int argc, char *argv[])
+{
+    // 只读模式打开命名管道
+    int read_fd = open("named_pipe", O_RDONLY);
+    if (read_fd == -1){
+        printf("Open fifo error!\n");
+        exit(-1);
+    }
+
+    char buf[SIZE];
+    int readBytes;
+    printf("Read data as follows: \n");
+    while ((readBytes = read(read_fd, buf, sizeof(buf))) > 0)
+    {
+        printf("%s\n", buf);
+    }
+
+    unlink("named_pipe");   //删除FIFO
+    return 0;
+}

Coding/Linux_OS_Pipe_R.cpp

@@ -0,0 +1,38 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-08-28 16:37:05
+ */
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <cstdlib>
+#include <cstring>
+
+const int SIZE = 1024;
+
+int main(int argc, char *argv[])
+{
+    // 创建匿名管道
+    if (mkfifo("named_pipe", 0644) == -1){
+        printf("Create named pipe failed.\n");
+        exit(-1);
+    }
+
+    printf("Open named pipe with pending modle...\n");
+    int write_fd = open("named_pipe", O_WRONLY);     //打开文件
+    if (write_fd == -1){
+        printf("Open named pipe failed!\n");
+        exit(-1);
+    }
+    const char *content = "1111222233334444";
+    if(write(write_fd, content, strlen(content)) != -1)
+    {
+        printf("Write data: \n");
+        printf("%s\n", content);
+    }
+    close(write_fd);
+    return 0;
+}
+

Coding/Linux_OS_Pipe_W.cpp

@@ -59,7 +59,6 @@ InnoDB也使用B+Tree作为索引结构，但具体实现方式却与MyISAM截
 * 外键约束；
 * 行锁定。
 
-
 # 更多阅读
 
 [MySQL: InnoDB 还是 MyISAM?](http://coolshell.cn/articles/652.html)   

DataBase/Engine.md

@@ -14,7 +14,7 @@
 SQL标准中定义了4种隔离级别，每一个级别都规定了一个事务中所做的修改，哪些在事务内和事务间是可见的，哪些是不可见的。较低级别的隔离通常可以执行更高地并发，系统的开销也更低。
 
 * READ UNCOMMITED（未提交读）：事务中的修改，即使没有提交，对其它事务也都是可见的。可能发生`脏读`：即事务可以读取未提交的数据。（实际中很少使用）
-* READ COMMITTED（提交读）：满足事务隔离性的简单定义：一个事务开始时，只能看见已经提交的事务所做的修改。这个级别有时候也叫做`不可重复读`，因为它不保证事务重新读的时候能读到相同的数据，因为在每次数据读完之后其他事务可以修改刚才读到的数据。考虑下面这种情况：A事务读取一个数据项var=1，然后B事务更新该数据var=2并提交，A事务接着又重新读了该数据，结果var=2，第二次读到的数据和第一次的不相同。大多数数据库系统的默认隔离级别是 READ COMMITTED（但是MySQL不是）
+* READ COMMITTED（提交读）：满足事务隔离性的简单定义：一个事务开始时，只能看见已经提交的事务所做的修改。这个级别有时候也叫做`不可重复读`，因为它不保证事务重新读的时候能读到相同的数据，因为在每次数据读完之后其他事务可以修改刚才读到的数据。考虑下面这种情况：A事务读取一个数据项var=1，然后B事务更新该数据var=2并提交，A事务接着又重新读了该数据，结果var=2，第二次读到的数据和第一次的不相同。大多数数据库系统的默认隔离级别是 READ COMMITTED（但是MySQL不是）。
 * REPEATABLE READ（可重复读）：只允许读取已经提交的数据，而且`在一个事务两次读取一个数据项期间，其它事务不得更新该数据`。但该事务不要求和其它事务可串行化。可能存在`幻读`问题：当某个事物在读取某个范围内的记录时，另外一个事务又在该范围内插入了新的记录，当之前的事务再次读取该范围的记录时，会产生幻行。可重复读是 MySQL 的默认事务隔离级别。
 * SERIALIZABLE（可串行化）：最高的隔离级别，通过强制事务串行执行，避免前面的幻读问题。会在读取的每一行数据上都加锁，所以可能导致大量的超时和锁争用的问题。
 

DataBase/SQL_More.md

@@ -0,0 +1,59 @@
+Java是一个支持并发、基于类和面向对象的计算机编程语言。
+
+
+
+String 是最基本的数据类型吗？ 
+
+Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）。
+
+# 数据类型
+
+Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。 
+
+Java 为每个原始类型提供了包装类型： 
+
+- 原始类型: boolean，char，byte，short，int，long，float，double 
+- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
+
+看下面简单的示例：
+
+```Java
+class AutoUnboxingTest {
+    public static void main(String[] args) {
+        Integer a = new Integer(3);
+        Integer b = 3;                  // 将3自动装箱成Integer类型
+        int c = 3;
+        System.out.println(a == b);     // false 两个引用没有引用同一对象
+        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
+        
+        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
+        System.out.println(f1 == f2);   // true
+        System.out.println(f3 == f4);   // false
+    }
+}
+```
+
+需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的 == 运算比较的不是值而是引用。如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中`f1==f2`的结果是true，而`f3==f4`的结果是false。
+
+String和StringBuilder、StringBuffer的区别？ 
+
+Java平台提供了两种类型的字符串：String和StringBuffer/StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer要高
+
+
+# 常用函数
+
+```Java
+System.out.println(Math.round(11.5));   // 12
+System.out.println(Math.round(-11.5));  // -11
+```
+
+round() 在参数上加0.5然后进行下（小）取整。
+
+
+# JVM 机制
+
+
+# 更多阅读
+
+[Java面试题全集（上）](http://blog.csdn.net/jackfrued/article/details/44921941)  
+

Java/README.md

@@ -82,7 +82,7 @@ fork()系统调用是Unix下以自身进程创建子进程的系统调用，一
 
 就没有问题了（就是6个“-”了），因为程序遇到“\n”，或是EOF，或是缓冲区满，或是文件描述符关闭，或是主动flush，或是程序退出，就会**把数据刷出缓冲区**。需要注意的是，标准输出是行缓冲，所以遇到“\n”的时候会刷出缓冲区，但对于磁盘这个块设备来说，“\n”并不会引起缓冲区刷出的动作，那是全缓冲，你可以使用setvbuf来设置缓冲区大小，或是用fflush刷缓存。
 
-参考：  
+# 更多阅读  
 [陈皓：一个 fork 的面试题](http://blog.jobbole.com/24686/)