Рефераты. Блокировки в MS SQL Server 2000

Блокировки в MS SQL Server 2000

Алексей Ширшов

Введение

Обычно блокировки рассматривают совместно с транзакциями. В данной статье упор делается в основном на механизм блокировок, его внутреннее устройство и использование в СУБД MS SQL Server 2000. Предполагается, что читатель хорошо знаком с транзакциями и их свойствами. Давайте вспомним вкратце, какими свойствами должны обладать транзакции в современных СУБД (эти требования носят название ACID – Atomicity, Consistency, Isolation и Durability):

Atomicity (атомарность). Это требование заключается в том, что все данные, с которыми работает транзакция, должны быть либо подтверждены (commit), либо отменены (rollback). Не должно быть ситуации, когда часть изменений подтверждается, а часть – отменяется. Это правило автоматически выполняется для простых данных.

Consistency (согласованность). После выполнения транзакции все данные должны остаться в согласованном состоянии. Другими словами, транзакция либо не изменит данных, и они останутся в прежнем состоянии, либо измененные данные будут удовлетворять ограничениям целостности, правилам (rules) и другим критериям согласованности данных.

Isolation (изолированность). Транзакции должны выполнятся автономно и независимо от других транзакций. При одновременном выполнении множества конкурирующих друг с другом транзакций, любое обновление определенной транзакции будет скрыто от остальных до тех пор, пока эта транзакция не будет зафиксирована. Существуют несколько уровней изолированности (изоляции) транзакций, которые позволяют выбрать наиболее оптимальное решение с точки зрения производительности и целостности данных. Основным методом реализации этих уровней и являются блокировки, о которых пойдет речь в этой статье.

Durability (долговечность или устойчивость). Это требование заключается в том, что после подтверждения изменения данных (фиксации транзакции) система переходит в новое состояние и возврат к старому состоянию не возможен, т.е. не возможен откат в предыдущее состояние. Для вложенных транзакций это требование нарушается.

В данной статье рассматриваются механизмы реализации уровней изолированности транзакции. Стандартом ANSI были определены четыре уровня изоляции транзакций. Первый – это нулевой уровень изоляции, второй – первый уровень и так далее. Эти уровни помогают решать различные проблемы, которые будут рассматриваться подробно далее в процессе написания демонстрационной программы на С++. Определения уровней будут даны в конце раздела.

Итак, чтобы лучше понять проблемы изоляции транзакций, рассмотрим их сначала с точки зрения программирования на С++. Так как наша программа будет оперировать простыми данными (значение типа int), будем считать, что требования атомарности выполняются автоматически. Кроме того, мы не будем налагать каких-либо логических ограничений на значение переменной и не будем использовать вложенных транзакций, так что требования согласованности и устойчивости также будут опущены.

Наша программа содержит всего два класса: CObject и CProxy. Класс CObject - это объект-одиночка (singleton), который содержит переменную value (доступ к этой переменной мы и будем защищать), и некоторый набор служебных функций. Класс CProxy представляет собой посредника для объекта CObject; именно с ним будет работать клиент. Вот первоначальный набросок (в классе CProxy используется нестандартная конструкция __declspec(property), поддерживаемая только компиляторами от Microsoft):

class CObject;

class CProxy

{

friend class CObject;

public:

__declspec(property(get=get_Value,put=put_Value)) int value;

int get_Value(int level = -1) const;

void put_Value(int i);

void Commit();

void Rollback();

private:

int _level;

int _value;

bool fUpd;

CProxy(CObject* par,int level)

{

fUpd = false;

parent = par;

_level = level;

}

CObject* parent;

};

class CObject

{

friend class CProxy;

public:

static CProxy& GetObject(int level = -1);

~CObject()

{

if (hMutex) CloseHandle(hMutex);

}

protected:

CProxy& BeginTran(int level)

{

return *(new CProxy(this,level));

}

void RequestExclusive(int level)

{

}

void RequestShared(int level)

{

}

void RemoveShared(int level)

{

}

void RemoveLocks()

{

}

private:

CObject()

{

value = 0;

}

int value;

static HANDLE hMutex;

};

__declspec(selectany) HANDLE CObject::hMutex = NULL;

CProxy& CObject::GetObject(int level)

{

HANDLE hLocMutex = CreateMutex(NULL,TRUE,_T("Guard-Lock-Mutex"));

bool flg = GetLastError() == ERROR_ALREADY_EXISTS;

if (flg) WaitForSingleObject(hLocMutex,INFINITE);

else CObject::hMutex = hLocMutex;

static CObject obj;

ReleaseMutex(hLocMutex);

if (flg) CloseHandle(hLocMutex);

return obj.BeginTran(level);

}

void CProxy::Commit()

{

parent->RemoveLocks();

delete this;

}

void CProxy::Rollback()

{

if (fUpd)

parent->value = _value;

parent->RemoveLocks();

delete this;

}

void CProxy::put_Value(int i)

{

parent->RequestExclusive(_level);

if (!fUpd)

_value = parent->value;

parent->value = i;

fUpd = true;

}

int CProxy::get_Value(int level) const

{

if (level == -1)

level = _level;

parent->RequestShared(level);

int v = parent->value;

parent->RemoveShared(level);

return v;

}