MySQL入门二之一些小注意点

Posted on 03-02-2015 | In DB

distinct关键字

distinct是应用于所有列的, 而不是某一个列

mysql> select * from test_table;
+------+------+
| one  | two  |
+------+------+
| 56   | 12   |
| 52   | 10   |
| 56   | 12   |
| 56   | 13   |
+------+------+
4 rows in set (0.00 sec)

mysql> select distinct one, two from test_table;
+------+------+
| one  | two  |
+------+------+
| 56   | 12   |
| 52   | 10   |
| 56   | 13   |
+------+------+
3 rows in set (0.00 sec)

mysql> select distinct one from test_table;
+------+
| one  |
+------+
| 56   |
| 52   |
+------+
2 rows in set (0.00 sec)

. . .

MySQL入门一之增删查改与关联

Posted on 02-27-2015 | In DB

增删改查

INSERT INTO table_name (列1, 列2,…) VALUES (值1, 值2,….)
DELETE FROM 表名称 WHERE 列名称 = 值
UPDATE 表名称 SET 列名称 = 新值 WHERE 列名称 = 某值
SELECT 列名称 FROM 表名称

关联

SQL join 用于根据两个或多个表中的列之间的关系，从这些表中查询数据。

Join和Key概绍

有时为了得到完整的结果，我们需要从两个或更多的表中获取结果。我们就需要执行 join。
数据库中的表可通过键将彼此联系起来。主键（Primary Key）是一个列，在这个列中的每一行的值都是唯一的。在表中，每个主键的值都是唯一的。这样做的目的是在不重复每个表中的所有数据的情况下，把表间的数据交叉捆绑在一起。
请看 “Persons” 表：

Id_P	LastName	FirstName	Address	City
1	Adams	John	Oxford Street	London
2	Bush	George	Fifth Avenue	New York
3	Carter	Thomas	Changan Street	Beijing

请注意，”Id_P” 列是 Persons 表中的的主键。这意味着没有两行能够拥有相同的 Id_P。即使两个人的姓名完全相同，Id_P 也可以区分他们。
接下来请看 “Orders” 表：

Id_O	OrderNo	Id_P
1	77895	3
2	44678	3
3	22456	1
4	24562	1
5	34764	65

请注意，”Id_O” 列是 Orders 表中的的主键，同时，”Orders” 表中的 “Id_P” 列用于引用 “Persons” 表中的人，而无需使用他们的确切姓名。
请留意，”Id_P” 列把上面的两个表联系了起来。

下面列出了您可以使用的 JOIN 类型，以及它们之间的差异。

JOIN(INNER JOIN): 如果左右表中都有至少一个匹配，则返回行
LEFT JOIN: 即使右表中没有匹配，也从左表返回所有的行
RIGHT JOIN: 即使左表中没有匹配，也从右表返回所有的行
FULL JOIN: 只要其中一个表中存在匹配，就返回行

注 : JOIN使用on的, 而不是where.

使用Join(INNER JOIN)

除了上面的方法，我们也可以使用关键词 JOIN 来从两个表中获取数据。
如果我们希望列出所有人的定购，可以使用下面的 SELECT 语句：

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
INNER JOIN Orders
ON Persons.Id_P = Orders.Id_P
ORDER BY Persons.LastName

结果集：

LastName	FirstName	OrderNo
Adams	John	22456
Adams	John	24562
Carter	Thomas	77895
Carter	Thomas	44678

使用Left Join

现在，我们希望列出所有的人，以及他们的定购 - 如果有的话。
您可以使用下面的 SELECT 语句：

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
LEFT JOIN Orders
ON Persons.Id_P=Orders.Id_P
ORDER BY Persons.LastName

结果集：

LastName	FirstName	OrderNo
Adams	John	22456
Adams	John	24562
Carter	Thomas	77895
Carter	Thomas	44678
Bush	George	- - - -

LEFT JOIN 关键字会从左表 (Persons) 那里返回所有的行，即使在右表 (Orders) 中没有匹配的行。

使用Right Join

现在，我们希望列出所有的定单，以及定购它们的人 - 如果有的话。
您可以使用下面的 SELECT 语句：

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
RIGHT JOIN Orders
ON Persons.Id_P=Orders.Id_P
ORDER BY Persons.LastName

结果集：

LastName	FirstName	OrderNo
Adams	John	22456
Adams	John	24562
Carter	Thomas	77895
Carter	Thomas	44678
		34764

RIGHT JOIN 关键字会从右表 (Orders) 那里返回所有的行，即使在左表 (Persons) 中没有匹配的行。

使用Full Join

现在，我们希望列出所有的人，以及他们的定单，以及所有的定单，以及定购它们的人。
您可以使用下面的 SELECT 语句：

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
FULL JOIN Orders
ON Persons.Id_P=Orders.Id_P
ORDER BY Persons.LastName

结果集：

LastName	FirstName	OrderNo
Adams	John	22456
Adams	John	24562
Carter	Thomas	77895
Carter	Thomas	44678
Bush	George
		34764

FULL JOIN 关键字会从左表 (Persons) 和右表 (Orders) 那里返回所有的行。如果 “Persons” 中的行在表 “Orders” 中没有匹配，或者如果 “Orders” 中的行在表 “Persons” 中没有匹配，这些行同样会列出。

ProtoBuf的安装与使用

Posted on 02-23-2015 | In Misc

介绍

与 JSON 相比， Protobuf 的序列化和反序列化的速度更快，而且传输的数据会先压缩，
使得传输的效率更高些。
Protobuf ，全称 Protocol Buffer ，是 Google 公司内部的混合语言数据标准，是一种轻便
高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据
存储或 RPC 数据交换格式。 Protobuf是可用于通信协议、数据存储等领域的语言无关、平台
无关、可扩展的序列化结构数据格式。

安装

谷歌的东西要想在大陆安装起来总是有点那啥, 你懂的.

需要的依赖

sudo apt-get install curl

sudo apt-get install autoconf autogen

sudo apt-get install libtool

安装步骤

下载自github的代码需要首先执行 $ ./autogen.sh 生成configure文件

注意autogen.sh 需要gtest包，默认是从 googletest.googlecode.com下载，国内需要翻墙才能访问，很多人问autogen.sh运行失败，这里我补充一下

修改一下autogen.sh , 将这段:

echo "Google Test not present.  Fetching gtest-1.5.0 from the web..."
curl http://googletest.googlecode.com/files/gtest-1.5.0.tar.bz2 | tar jx
mv gtest-1.5.0 gtest

修改为:

wget https://github.com/google/googletest/archive/release-1.5.0.tar.gz
tar xzvf release-1.5.0.tar.gz
mv googletest-release-1.5.0 gtest

再执行 autogen.sh，这样就不会报错了

$ ./configure
$ make
$ make check
$ make install

默认是装在

usr/local/bin
usr/local/lib,
usr/local/include

检查是否安装成功

protoc --version

如果安装成功,会出现版本号如

libprotoc 2.6.1

如果有问题，会输出错误内容, 最后我安装完成,用上述命令检查版本号时出现如下问题

protoc: error while loading shared libraries: libprotocbuf.so.9: cannot open shared

错误原因

protobuf的默认安装路径是/usr/local/lib,而/usr/local/lib不在ubuntu体系默认的LD_LIBRARY_PATH里,所以就找不到lib

解决办法 :

1 - 在 /etc/ld.so.conf.d/目录下创建文件 bprotobuf.conf文件,文件内容如下

/usr/local/lib

2 - 输入命令

sudo ldconfig

这时,再输入protoc --version就可以正常看到版本号了

使用

Writer.cpp

#include<iostream>
#include<fstream>
#include "Mymessage.pb.h"
using namespace std;
int main(){
	Im::Content msg1;
	msg1.set_id(101);
	msg1.set_str("ggsmd");
	fstream output("./log", ios::out | ios::trunc | ios::binary); 
	if (!msg1.SerializeToOstream(&output)) {
		cerr << "Failed to write msg." << endl; 
		return -1;
	}
	return 0; 
}

Reader.cpp

#include<iostream>
#include<fstream>
#include "Mymessage.pb.h"
using namespace std;
void ListMsg(const Im::Content & msg){
	cout << msg.id() << endl; 
	cout << msg.str() << endl;
} 
int main(int argc, char* argv[]){
	Im::Content msg1;
	fstream input("./log", ios::in | ios::binary);
	if (!msg1.ParseFromIstream(&input)) {
		cerr << "Failed to parse address book." << endl; 
		return -1;
	} 
	ListMsg(msg1);
	return 0;
}

makefile

INC=/usr/local/include
LIB=/usr/local/lib
lib=protobuf

all:Writer Reader

Writer.o:Writer.cpp
	g++ -g -c Writer.cpp -I$(INC) -L$(LIB) -l$(lib)
Reader.o:Reader.cpp
	g++ -g -c Reader.cpp -I$(INC) -L$(LIB) -l$(lib)	

Writer:Writer.o Mymessage.pb.o 
	g++ -g -o Writer Writer.o Mymessage.pb.o -I$(INC) -L$(LIB) -l$(lib)
Reader:Reader.o Mymessage.pb.o 
	g++ -g -o Reader Reader.o Mymessage.pb.o -I$(INC) -L$(LIB) -l$(lib)
Mymessage.pb.o:Mymessage.pb.cc
	g++ -g -c Mymessage.pb.cc -I$(INC) -L$(LIB) -l$(lib)	

clean:Writer Reader Writer.o Reader.o Mymessage.pb.o
	rm Writer Reader Writer.o Reader.o Mymessage.pb.o

Mymessage.proto

package Im; 
message Content 
{ 
    required int32   id = 1;  // ID 
    required string  str = 2;  // str 
    optional int32   opt = 3;  //optional field 
}

打印结果

执行
protoc -I=./ --cpp_out=./ Mymessage.proto
命令后，会生成 Mymessage.pb.h 和 Mymessage.pb.cc 文件。再执行 make 命令，生成
Writer 和 Reader 文件。执行 ./Writer 命令后，再执行./Reader 命令，终端上输出：

b@b-VirtualBox:~/tc$ protoc -I=./ --cpp_out=./ Mymessage.proto
b@b-VirtualBox:~/tc$ ll
total 44
drwxrwxr-x 2 b b  4096  5月 19 22:43 ./
drwxr-xr-x 4 b b  4096  5月 19 22:35 ../
-rw-rw-r-- 1 b b   647  5月 19 22:36 makefile
-rw-rw-r-- 1 b b 12214  5月 19 22:43 Mymessage.pb.cc
-rw-rw-r-- 1 b b  7762  5月 19 22:43 Mymessage.pb.h
-rw-rw-r-- 1 b b   161  5月 19 22:36 Mymessage.proto
-rw-rw-r-- 1 b b   421  5月 19 22:36 Reader.cpp
-rw-rw-r-- 1 b b   340  5月 19 22:35 Writer.cpp

b@b-VirtualBox:~/tc$ make
g++ -g -c Writer.cpp -I/home/sharexu/charpter13/1302/include -L/home/sharexu/charpter13/1302/lib -lprotobuf
g++ -g -c Mymessage.pb.cc -I/home/sharexu/charpter13/1302/include -L/home/sharexu/charpter13/1302/lib -lprotobuf    
g++ -g -o Writer Writer.o Mymessage.pb.o -I/home/sharexu/charpter13/1302/include -L/home/sharexu/charpter13/1302/lib -lprotobuf
g++ -g -c Reader.cpp -I/home/sharexu/charpter13/1302/include -L/home/sharexu/charpter13/1302/lib -lprotobuf    
g++ -g -o Reader Reader.o Mymessage.pb.o -I/home/sharexu/charpter13/1302/include -L/home/sharexu/charpter13/1302/lib -lprotobuf

b@b-VirtualBox:~/tc$ ll
total 772
drwxrwxr-x 2 b b   4096  5月 19 22:43 ./
drwxr-xr-x 4 b b   4096  5月 19 22:35 ../
-rw-rw-r-- 1 b b    647  5月 19 22:36 makefile
-rw-rw-r-- 1 b b  12214  5月 19 22:43 Mymessage.pb.cc
-rw-rw-r-- 1 b b   7762  5月 19 22:43 Mymessage.pb.h
-rw-rw-r-- 1 b b 244112  5月 19 22:43 Mymessage.pb.o
-rw-rw-r-- 1 b b    161  5月 19 22:36 Mymessage.proto
-rwxrwxr-x 1 b b 188430  5月 19 22:43 Reader*
-rw-rw-r-- 1 b b    421  5月 19 22:36 Reader.cpp
-rw-rw-r-- 1 b b  57656  5月 19 22:43 Reader.o
-rwxrwxr-x 1 b b 184244  5月 19 22:43 Writer*
-rw-rw-r-- 1 b b    340  5月 19 22:35 Writer.cpp
-rw-rw-r-- 1 b b  59232  5月 19 22:43 Writer.o

b@b-VirtualBox:~/tc$ ./Writer    

b@b-VirtualBox:~/tc$ ./Reader 
101
ggsmd

C++对象模型之虚函数实例讲解

Posted on 02-21-2015 | In Misc

介绍

因为c++只规定了虚继承/ 虚函数/ 多继承/ 的行为, 但将实现方法留给编译器作者. 所以各个平台的实现并不相同, 得出的结果也不尽相同.

经测试, vs和gcc目前比较统一的情况只有2种 :

无继承+无虚函数
无继承+虚函数

故本文只讨论这2种, 以及了解虚函数和虚继承的含义.

. . .

python中的name和main()

Posted on 02-10-2015 | In Misc

#hello.py
def sayHello():
    str="hello"
    print(str);

if __name__ == "__main__":
    print ('This is main of module "hello.py"')
    sayHello()

python作为一种脚本语言，我们用python写的各个module都可以包含以上那么一个累死c中的main函数，只不过python中的这种__main__与c中有一些区别，类似于php的魔术那一套, 主要体现在：

1、当单独执行该module时，比如单独执行以上hello.py： python hello.py，则输出

This is main of module "hello.py"
hello

可以理解为"if __name__=="__main__":"这一句与c中的main()函数所表述的是一致的，即作为入口；

2、当该module被其它module 引入使用时，其中的"if __name__=="__main__":"

所表示的Block不会被执行,

这是因为此时module被其它module引用时，

其__name__的值将发生变化，__name__的值将会是module的名字。

比如在python shell中import hello后，查看hello.__name__：

import hello
hello.__name__
'hello'

3、因此，在python中，当一个module作为整体被执行时,moduel.name的值将是"__main__"；

而当一个module被其它module引用时，module.__name__将是module自己的名字，

当然一个module被其它module引用时，其本身并不需要一个可执行的入口main了。

条件编译指令之#if和#ifdef和#if defined之间的区别

Posted on 02-09-2015 | In Misc

#if的使用说明

#if的后面接的是表达式 :

#if (MAX==10)||(MAX==20)
 code...
#endif

它的作用是：如果(MAX==10)||(MAX==20)成立，那么编译器就会把其中的#if 与 #endif之间的代码编译进去（注意：是编译进去，不是执行！！）

#if defined的使用

#if后面接的是一个宏, 而#if define(x)的使用如下 :

#if defined (x)
    ...code...
#endif

这个#if defined它不管里面的“x”的逻辑是“真”还是“假”它只管这个程序的前面的宏定义里面有没有定义“x”这个宏，如果定义了x这个宏，那么，编译器会编译中间的…code…否则不直接忽视中间的…code…代码。
另外 #if defined(x)也可以取反，也就用 #if !defined(x)

#ifdef的使用

#ifdef的使用和#if defined()的用法一致
#ifndef又和#if !defined()的用法一致。

最后强调两点：

这几个宏定义只是决定代码块是否被编译！
别忘了#endif

Lua特别之处笔记

Posted on 02-03-2015 | In Misc

2.2 Booleans

两个取值 false 和 true。但要注意 Lua 中所有的值都可以作为条件。在控制结构的条
件中除了 false 和 nil 为假，其他值都为真。所以 Lua 认为 0 和空串都是真。

2.5 table

我们用一个疑问来引入table的介绍

传的是值还是引用?

lua的函数调用传的是值还是引用?

. . .

单例模式的析构问题和线程安全问题

Posted on 02-02-2015 | In Misc

在某些应用环境下面，一个类只允许有一个实例，这就是著名的单例模式。
单例模式分为

懒汉模式
饿汉模式

饿汉模式

在实例化 m_instance 变量时，直接调用类的构造函数。顾名思义，在还未使用变量时，已经对 m_instance 进行赋值，就像很饥饿的感觉。
在main开始前就初始化好了，所以是线程安全的。

没有考虑析构问题饿汉模式的示例代码

首先给出没有考虑析构问题的饿汉模式的实现

#include <iostream>

using namespace std;


class singleton
{
protected:
	singleton() {};
private:
	singleton(const singleton&) {};
	singleton& operator=(const singleton&) {};
	static singleton* m_instance;
public:
	static singleton* GetInstance();
	~singleton()
	{
		printf("Singleton destruction\n");
	}
};


singleton* singleton::GetInstance()
{
	return m_instance;
}


singleton* singleton::m_instance = new singleton;

int main()
{
	singleton *ct = singleton::GetInstance();
	return 0;
}

饿汉模式的优点

线程安全
实现简单，容易维护

饿汉模式的缺点

不适合部分场景。如：因为性能问题，希望懒加载；需要运行时才能知道，是否生成实例
由于在main开始前就必须初始化，几乎不可能给类传入任何参数。

懒汉模式

懒汉模式下，在定义m_instance变量时先等于NULL，在调用GetInstance()方法时，在判断是否要赋值。这种模式，并非是线程安全的，因为多个线程同时调用GetInstance()方法，就可能导致有产生多个实例。

没有考虑线程安全与析构问题的懒汉模式的示例代码

下面是没有考虑线程安全以及析构问题的懒汉模式的代码实现

#include <iostream>

using namespace std;

class singleton
{
protected:
	singleton() {};
private:
	singleton(const singleton&) {};
	singleton& operator=(const singleton&) {};
	static singleton* m_instance;
public:
	static singleton* GetInstance();
	~singleton()
	{
		printf("Singleton destruction\n");
	}
};

singleton* singleton::GetInstance()
{
	if (m_instance == NULL)
	{
		m_instance = new singleton;
	}
	return m_instance;
}

singleton* singleton::m_instance = NULL;

int main()
{
	singleton *ct = singleton::GetInstance();
	return 0;
}

解决懒汉模式线程安全问题的几种方法

有下面几种方法 :

使用局部静态变量
加锁
pthread_once
DCL

使用局部静态变量

使用局部静态变量。
局部静态变量的初始化是线程安全的，这一点由编译器保证.（http://gcc.gnu.org/ml/gcc-patches/2004-09/msg00265.html，这是一个 GCC 的 patch，专门解决这个问题）。会在程序退出的时候自动销毁。
见此处

这个方法适合 C++11，C++11保证静态局部变量的初始化是线程安全的。
如果是 C++98 就不能用这个方法。

非摸板版本

class S
{
    public:
        static S& getInstance()
        {
            static S    instance;
            return instance;
        }
    private:
        S() {}
        S(S const&);              // Don't Implement.
        void operator=(S const&); // Don't implement
 };

或者

模板版本

template<typename T>
class Singleton
{
public:
    static T& GetInstance()
    {
        static T instance;
        return instance;
    }

    Singleton(T&&) = delete;
    Singleton(const T&) = delete;
    void operator= (const T&) = delete;

protected:
    Singleton() = default;
    virtual ~Singleton() = default;
};

加锁

线程安全，但每次都有开销。

// singleton.h
class Singleton {
    public:
        static Singleton *GetInstance() {
            lock();
            if (p == NULL) {
                p = new Singleton;
            }
			unlock();
            return p;
        }
    private:
    static Singleon *p;
    Singleton() {}
    Singleton(const Singleton &);
    Singleton& operator= (const Singleton &);
};

// singleton.cc
Singleton *Singleton::p = NULL;

pthread_once

陈硕推荐的做法

class Singleton {
    public:
        static Singleton *GetInstance() {
            pthread_once(&ponce_, &Singleton::init);
            return value_;
        }
        private:
        Singleton() {}
        Singleton(const Singleton &);
        Singleton& operator= (const Singleton &);
        static void init() {
            value_ = new T();
        }
        static pthread_once_t ponce_;
        static Singleton *value_;
};
pthread_once_t SIngleton::ponce_ = PTHREAD_ONCE_INIT;
Singleton* Singleton::value_ = NULL;

DCL

double check locking. 只能用内存屏障，其他做法都是有问题的。
参见论文： http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
普通的 double check 之所以错，是因为乱序执行和多处理器下，不同 CPU 中间 cache 刷往内存并对其他 CPU 可见的顺序无法保障（cache coherency problem）。
Singleton<T> *p = new Singleton<T>;, 那么实际有 3 步：

分配内存
构造
赋值给 p

2 和 3 的顺序是未定的（乱序执行！）。因此，如果直接赋值给 p 那么很可能构造还没完成。此时另一个线程调用 GetInstance，在 lock 外面 check 了一下，发现 p!=NULL，于是直接返回 p，使用了未初始化完成的实例，跪了。

那么，如果用中间变量转一下呢？用 tmp_p 转了下以后，tmp_p 赋值给 p 的时候，显然 p 指向的实例是构造完成了的。然而，这个 tmp_p 在编译器看来明显没什么用，会被优化掉。

关于不能自动调用析构的问题

上面的两个示例代码
( 没有考虑析构问题饿汉模式的示例代码和没有考虑线程安全与析构问题的懒汉模式的示例代码 ) 都有不能自动调用析构的问题.

当你运行这两个示例代码之后, 你都会发现并没有打印 “Singleton destruction”, 也就是说程序结束时并没有调用 singleton 类的析构函数的, 为什么呢?

因为 m_instance = new singleton;, new出来的东西需要delete掉, 如果加上一句 delete ct; ct = NULL;, 就会调用析构函数了.
但这种手动调用很容易忘啊, 怎么才能自动调用它的析构呢?

我们想要的是 : 自动化的正常删除该实例。

有两种方法, 我给他划分为:

不需要加GC(垃圾回收)内嵌类的单例模式(推荐)
需要加GC(垃圾回收)内嵌类的单例模式

需要加GC内嵌类的单例模式

我们先看第二种,

我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。
那就是定义一个内部垃圾回收GC类，并且在 singleton 中定义一个此类的静态成员。程序结束时，系统会自动析构此静态成员，此时，在此类的析构函数中析构 singleton 实例，就可以实现 m_instance 的自动释放。

#include <iostream>

using namespace std;

class singleton
{
protected:
	singleton() {};
private:
	singleton(const singleton&) {};
	singleton& operator=(const singleton&) {};
	static singleton* m_instance;
public:
	static singleton* GetInstance();
	~singleton()
	{
		printf("Singleton destruction\n");
	}
	
	class GC
	{
	public:
		~GC()
		{
			printf("GC destruction\n");
			if (m_instance)
			{
				delete m_instance;
				m_instance = NULL;
			}
		}
	};
	static GC gc_singleton;
};

singleton::GC singleton::gc_singleton;

singleton* singleton::GetInstance()
{
	if (m_instance == NULL)
	{
		m_instance = new singleton();
	}
	return m_instance;
}

singleton* singleton::m_instance = NULL;

int main()
{
	singleton *ct = singleton::GetInstance();
	return 0;
}

当然还有更好的方法.那就是下面这个不需要加GC内嵌类的单例模式.

不需要加GC内嵌类的单例模式

在 GetInstance 方法里放一个 m_instance 的局部静态变量, 然后返回他的地址, 他就可以在程序结束自动调用析构函数.
而且这种方法在C++11也能保证线程安全.

#include <iostream>

using namespace std;

class singleton
{
protected:
	singleton() {};
private:
	singleton(const singleton&) {};
	singleton& operator=(const singleton&) {};
public:
	static singleton* GetInstance();
	~singleton()
	{
		printf("Singleton destruction\n");
	}
};

singleton* singleton::GetInstance()
{
	static singleton m_instance;
	return &m_instance;
}

int main()
{
	singleton *ct = singleton::GetInstance();
	return 0;
}

总结

既要考虑线程安全又要考虑析构问题的话, 有下面几种方法 :

饿汉模式+GC内嵌类
懒汉模式+GC内嵌类, 然后加锁，但每个线程缓存了返回的指针，调用一次有用缓存的指针即可。
懒汉模式+GC内嵌类, 然后 pthread_once

如果是C++11的话, 则可以使用局部静态变量, 因为C++11保证静态局部变量的初始化是线程安全的(C++98不保证), 而且也没有析构问题.

Mike

🚙 🚗 💨 💨 If you want to create a blog like this, just follow my open-source project, "hexo-theme-neo", click the GitHub button below and check it out ^_^ . It is recommended to use Chrome, Safari, or Edge to read this blog since this blog was developed on Edge (Chromium kernel version) and tested on Safari.

GitHub Spotify