单例模式的四种线程安全的实现

1.懒汉经典模式，用互斥锁实现

#include <pthread.h>
#include <stdio.h>
#include <iostream>

class CSingletonLock{
private:
    pthread_mutex_t m_mutex;
public:
    CSingletonLock()
    {
        pthread_mutex_init(&m_mutex, NULL);
    }

    void Lock()
    {
        pthread_mutex_lock(&m_mutex);
    }

    void UnLock()
    {
        pthread_mutex_unlock(&m_mutex);
    }

};
class CSingleton{
private:
    CSingleton()
    {
    }

public:
    static pthread_mutex_t m_mutex;
    static CSingleton* getInstance();
    static CSingleton* m_ptIntance;
    static CSingletonLock *m_ptLock;
};

pthread_mutex_t CSingleton::m_mutex = PTHREAD_MUTEX_INITIALIZER;
CSingleton* CSingleton::m_ptIntance = NULL;
CSingletonLock* CSingleton::m_ptLock = new CSingletonLock(); 
CSingleton* CSingleton::getInstance()
{
    if (NULL == m_ptIntance)
    {
        m_ptLock->Lock();
        m_ptIntance = new CSingleton();
        m_ptLock->UnLock();
    }

    return m_ptIntance;
}

int g_getNum  = 0;
pthread_mutex_t countMutex = PTHREAD_MUTEX_INITIALIZER;
void* myThread(void * arg)
{
	while (1)
	{
		CSingleton *ptIntance = CSingleton::getInstance();
		pthread_mutex_lock(&countMutex);
		printf("thread[%d], addr:%p\n", *(int *)arg, ptIntance);
		if (40 == g_getNum)
		{
			pthread_mutex_unlock(&countMutex);
			return NULL;	
		}
		g_getNum++;
		pthread_mutex_unlock(&countMutex);
    }
	
	return (void *)0;
}

int main()
{
    pthread_t tid[20];
	pthread_mutex_init(&countMutex, NULL);
	int tidNum[20] = {0};
	for (int i = 0; i < 20; i++)
	{
		tidNum[i] = i + 1;
		pthread_create(&tid[i], NULL, myThread, (tidNum + i));
	}
	
	for (int i = 0; i < 20; i++)
	{
		pthread_join(tid[i], NULL);
	}
	printf("%d\n", g_getNum);
    return 0;
}

2.饿汉模式，直接在单例初始化时用new创建

#include <pthread.h>
#include <stdio.h>
#include <iostream>


class CSingleton{
private:
    CSingleton()
    {
    }

public:
    static CSingleton* getInstance();
    static CSingleton* m_ptIntance;

};


CSingleton* CSingleton::m_ptIntance = new CSingleton();
CSingleton* CSingleton::getInstance()
{
    if (NULL == m_ptIntance)
    {
        m_ptIntance = new CSingleton();
    }

    return m_ptIntance;
}

int g_getNum  = 0;
pthread_mutex_t countMutex = PTHREAD_MUTEX_INITIALIZER;
void* myThread(void * arg)
{
	while (1)
	{
		CSingleton *ptIntance = CSingleton::getInstance();
		pthread_mutex_lock(&countMutex);
		printf("thread[%d], addr:%p\n", *(int *)arg, ptIntance);
		if (40 == g_getNum)
		{
			pthread_mutex_unlock(&countMutex);
			return NULL;	
		}
		g_getNum++;
		pthread_mutex_unlock(&countMutex);
    }
	
	return (void *)0;
}

int main()
{
    pthread_t tid[20];
	pthread_mutex_init(&countMutex, NULL);
	int tidNum[20] = {0};
	for (int i = 0; i < 20; i++)
	{
		tidNum[i] = i + 1;
		pthread_create(&tid[i], NULL, myThread, (tidNum + i));
	}
	
	for (int i = 0; i < 20; i++)
	{
		pthread_join(tid[i], NULL);
	}
	printf("%d\n", g_getNum);
    return 0;
}

3.类中定义静态成员对象的实现

#include <pthread.h>
#include <stdio.h>
#include <iostream>


class CSingleton{
private:
    CSingleton()
    {
    }

public:
    static CSingleton* getInstance();
    static CSingleton m_Intance;

};

CSingleton CSingleton::m_Intance;

CSingleton* CSingleton::getInstance()
{

    return &m_Intance;
}

int g_getNum  = 0;
pthread_mutex_t countMutex = PTHREAD_MUTEX_INITIALIZER;
void* myThread(void * arg)
{
	while (1)
	{
		CSingleton *ptIntance = CSingleton::getInstance();
		pthread_mutex_lock(&countMutex);
		printf("thread[%d], addr:%p\n", *(int *)arg, ptIntance);
		if (40 == g_getNum)
		{
			pthread_mutex_unlock(&countMutex);
			return NULL;	
		}
		g_getNum++;
		pthread_mutex_unlock(&countMutex);
    }
	
	return (void *)0;
}

int main()
{
    pthread_t tid[20];
	pthread_mutex_init(&countMutex, NULL);
	int tidNum[20] = {0};
	for (int i = 0; i < 20; i++)
	{
		tidNum[i] = i + 1;
		pthread_create(&tid[i], NULL, myThread, (tidNum + i));
	}
	
	for (int i = 0; i < 20; i++)
	{
		pthread_join(tid[i], NULL);
	}
	printf("%d\n", g_getNum);
    return 0;
}

4.获取单例函数中定义static静态局部变量的实现

#include <pthread.h>
#include <stdio.h>
#include <iostream>


class CSingleton{
private:
    CSingleton()
    {
    }

public:
    static CSingleton* getInstance();

};


CSingleton* CSingleton::getInstance()
{

    static CSingleton singleton;

    return &singleton;

}

int g_getNum  = 0;
pthread_mutex_t countMutex = PTHREAD_MUTEX_INITIALIZER;
void* myThread(void * arg)
{
	while (1)
	{
		CSingleton *ptIntance = CSingleton::getInstance();
		pthread_mutex_lock(&countMutex);
		printf("thread[%d], addr:%p\n", *(int *)arg, ptIntance);
		if (40 == g_getNum)
		{
			pthread_mutex_unlock(&countMutex);
			return NULL;
		}
		g_getNum++;
		pthread_mutex_unlock(&countMutex);
    }

	return (void *)0;
}

int main()
{
    pthread_t tid[20];
	pthread_mutex_init(&countMutex, NULL);
	int tidNum[20] = {0};
	for (int i = 0; i < 20; i++)
	{
		tidNum[i] = i + 1;
		pthread_create(&tid[i], NULL, myThread, (tidNum + i));
	}

	for (int i = 0; i < 20; i++)
	{
		pthread_join(tid[i], NULL);
	}
	printf("%d\n", g_getNum);
    return 0;
}