hierarchical mutex

/****************************************************************************
@File Name: hierarchical_mutex.h
@Author: 
@mail: 
@Created Time: Sun 19 Mar 2017 09:17:24 AM CST
****************************************************************************/
#ifndef HIERARCHICAL_MUTEX_H
#define HIERARCHICAL_MUTEX_H
#include <thread>
#include <mutex>
#include <stdexcept>
#include <climits>
namespace hierarchical_mutex
{
using namespace std;
class HierarchicalMutex
{
private:
	mutex m_lock;
	unsigned long const m_current_value;		// current hierarchical value
	unsigned long m_previous_value;				// previous hierarchical value
	static thread_local unsigned long m_thisthread_value;
private:
	inline void check_hierarchy_violation()
	{
		if(m_thisthread_value <= m_current_value)
		{
			throw logic_error("mutex hierarchy violation...!\n");
		}
	}
	inline void update_hierarchy_value()
	{
		m_previous_value = m_thisthread_value;
		m_thisthread_value = m_current_value;
	}
public:
	explicit HierarchicalMutex(unsigned long value):m_current_value(value), m_previous_value(0)
	{
	}
	void lock();
	void unlock();
	bool try_lock();
};
}
#endif

/****************************************************************************
@File Name: hierarchical_mutex.h
@Author: 
@mail: 
@Created Time: Sun 19 Mar 2017 09:17:24 AM CST
****************************************************************************/
#include "hierarchical_mutex.h"
namespace hierarchical_mutex
{
thread_local unsigned long HierarchicalMutex::m_thisthread_value(ULONG_MAX);
void HierarchicalMutex::lock()
{
	check_hierarchy_violation();
	m_lock.lock();
	update_hierarchy_value();
}
void HierarchicalMutex::unlock()
{
	m_thisthread_value = m_previous_value;
	m_lock.unlock();
}
bool HierarchicalMutex::try_lock()
{
	check_hierarchy_violation();
	if(!m_lock.try_lock()) return false;
	update_hierarchy_value();
	return true;
}
}

/****************************************************************************
@File Name: main.cpp
@Author: 
@mail: 
@Created Time: Sun 19 Mar 2017 09:50:25 AM CST
****************************************************************************/
#include "hierarchical_mutex.h"
#include <iostream>
using namespace hierarchical_mutex;
HierarchicalMutex hm0(10);
HierarchicalMutex hm1(8);
void do_low_level()
{
	cout << "do_low_level()...!" << endl;
}
void do_high_level()
{
	cout << "do_high_level()...!" << endl;
}
void low_level_func()
{
	lock_guard<HierarchicalMutex>lk(hm1);
	do_low_level();
}
void high_level_func()
{
	lock_guard<HierarchicalMutex>lk(hm1);
	try
	{
		low_level_func();
	}
	catch(exception &e)
	{
		cerr << e.what();
	}
}
int main()
{
	thread th0(high_level_func);
	th0.join();

	return 0;
}

CC=g++
all:
	$(CC) -std=c++11 -g -o hierarchical_mutexTest main.cpp hierarchical_mutex.cpp hierarchical_mutex.h -pthread