'트랜잭션'에 해당되는 글 4건

  1. 2017.06.30 SQL Server DeadLock 4편
  2. 2017.06.25 SQL Server DeadLock 3편 4
  3. 2017.06.04 .NET IsolationLevel에 대한 고찰 5
  4. 2010.09.21 COM+ Transaction VS TransactionScope 8

SQL Server DeadLock 시리즈가 어느덧 4편까지 왔네요. 4편에서는 지금까지의 내용을 정리하고 3편에 이어 현실에서 발생한 DeadLock에 대한 원인과 해결책에 대해서 이야기를 해보겠습니다.


SQL Server DeadLock 1편

http://resisa.tistory.com/184


트랜잭션과 Lock에 대한 기본 개념과 IsolationLevel 중에 실제로 사용가능한 ReadUncommitted와 Snapshot에 대하여 설명을 하였습니다. 그리고 DB Lock의 종류(X, U, S)에 대하여 알아보았습니다.

여기서 자체 질문은 S-Lock의 아래 내용입니다.


하나의 트랜잭션에서 S-Lock 잠금을 설정하면 다른 트랜잭션에서도 U-Lock, S-Lock 잠금이 가능합니다. 

=> 해당 글을 쓸 때보다 조금 더 알게 되었으니 표현을 아래와 같이 고급지게 해보겠습니다. 


리소스에 S-Lock이 획득되고 동일 리소스에 다른 트랜잭션에서 U-Lock, S-Lock으로 호환 가능합니다.

=> Q : 동일 리소스에 S-Lock이 획득되고 X-Lock 호환은 왜 불가능한 것일까요? 

=> A : 솔직히 모르겠습니다 ㅎㅎㅎ 그냥 정의라고 생각하고 외워야 할것 같은 불길한 느낌이 듭니다. 논리적으로 딱 맞아 떨어지는건 없지만 맞추기 식의 논리를 펼치면 S-Lock은 읽기의 경우에 획득하는 잠금으로 Select문이 실행되는 순간에 S-Lock이 획득되고 실행이 완료되면 S-Lock이 바로 해제가 됩니다. 즉 S-Lock은 Lock이 획득되는 시간이 매우 짧으며 Dirty 데이터를 읽지 않기 위해서는 그 짧은 시간 동안에 X-Lock과 호환이 가능하게 할 필요가 없어 보입니다.

=> 여기서 꼭 말하고 싶은 것은 트랜잭션과 Lock에 대한 기본 개념을 이해하고 S-Lock의 경우 트랜잭션 내에서 잠금이 바로 해제된다는 것입니다.


SQL Server DeadLock 2편

http://resisa.tistory.com/185


2편에서는 리소스(KEY, PAG, TAB)에 대한 개념을 설명하고 DeadLock 예제와 함께 잠금의 호환성에 대하여 알아보았습니다. 해당 예제가 현실하고는 맞지 않는 예제였지만 1편에서 말하고 싶었던 S-Lock에 트랜잭션 내에서의 개념을 말하고 싶은 예제였습니다. 추가적으로 데이터의 양에 리소스가 변경될 수 있다는 것도 중요한 사실입니다. 이번 시리즈에서는 자체 질문은 아래와 같습니다.

Q : Intent Lock은 뭔가요??

A : 1편, 2편에 참고했던 사이트에서 아래와 같이 정의하고 있습니다.


특정 로우에 Lock을 설정하면 그와 동시에 상위 레벨 개체(페이지, 익스텐트, 테이블)에 내부적으로 의도(Intent) Lock이 설정된다. Lock을 설정하려는 개체의 하위 레벨에서 선행 트랜잭션이 어떤 작업을 수행 중인지를 알리는 용도로 사용되며, 일종의 푯말(Flag)이라고 할 수 있다. 예를 들어, 구조를 변경하기 위해 테이블을 잠그려 할 때 그 하위의 모든 페이지나 익스텐트, 심지어 로우에 어떤 Lock이 설정돼 있는지를 일일이 검사해야 한다면 좀처럼 작업이 끝나지 않을 수 있다. 의도 Lock은 그런 현상을 방지해 준다. 즉, 해당 테이블에 어떤 모드의 의도 Lock이 설정돼 있는지만 보고도 작업을 진행할지 아니면 기다릴지를 결정할 수 있다.

=> 이해가 잘되시나요? 대충 어떤 느낌인지는 천천히 읽어보면 알 수 있지만 딱 와닿지는 않을 수 있다고 생각됩니다. 그래서 예를 들어보면 특정 하나의 로우에 Update문을 실행하면 KEY(리소스)에 X-Lock 잠금이 획득됩니다. 이전 트랜잭션이 완료되지 않은 상황에서 다른 트랜잭션에 Insert는 당연히 가능해야 할 것으로 보입니다. 다시 이전으로 돌아가서 Update문을 실행할 때 KEY뿐만이 아니라 PAG, TAB에도 잠금이 발생하는데 Intent-Lock이라는 개념이 있어야 IX로 잠금을 걸고 다른 트랜잭션에서 실행하는 구문과 잠금의 호환성에 따라서 동시성을 높일 수 있을 것입니다.


SQL Server DeadLock 3편

http://resisa.tistory.com/187


3편에서는 자주 사용하는 테이블 힌트를 정리해보고 현실에서 있을 만한 DeadLock 예제를 살펴보았습니다. 트랜잭션에서 Select ~ Update 구문에서 발생하는 DeadLock의 해결책으로 WITH(UPDLOCK) 힌트를 주어 가장 먼저 진입한 트랜잭션이 완료될 때까지 다른 트랜잭션은 모두 블럭(대기)을 하는 알고리즘으로 Non-Repeatable Read도 발생하지 않도록 하였습니다.


이제 4편 본론에 해당하는 내용으로 3편 예제를 확장시켜 프로세스(트랜잭션) 3개에서 발생하는 DeadLock 예제를 살펴보도록 하겠습니다.

현재까지는 테이블 1개에 대해서만 어떤 리소스에 어떤 잠금이 획득되는지 살펴보았는데 테이블을 2개로 늘려보도록 하겠습니다.

테이블에 대한 정의는 아래와 같습니다.

1. 충전 테이블 : 사용자에 대한 충전 포인트 정보를 확인

2. 포인트 테이블 : 사용자의 누적 포인트를 확인

=>  충전 테이블에는 충전을 할 때마다 충전 정보가 쌓이게 됩니다. 예를 들어 100원 충전, 200원 충전 이런 정보들이 쌓이고 포인트 테이블에서는 해당 사용자는 300원을 보유하고 있다는 정보를 가지고 있는 구조입니다.


비지니스 로직은 충전과 차감이 있으며 기능적으로 아래와 같습니다.


 

 충전

 차감

 비고

 접근 테이블

 충전, 포인트 테이블

 충전, 포인트 테이블

- 다른 테이블도 있지만 여기서는 2개의 테이블을 대상으로만 이야기 합니다.

 기능

 1. 충전 테이블 Insert

 2. 포인트 테이블에 Select, Update 

 1. 포인트 테이블 Select

 2. 차감 로직

 3. 포인트 테이블 Select, Update

- 차감 로직은 생략

- 기능은 하나의 트랜잭션으로 구현

=> 3편에서 말했던 Non-Repeatable Read는 차감 기능 1번에서 발생합니다. 여기서 이해해야 하는 것은 차감을 병렬적으로 실행하다보면 포인트 테이블에 대한 Select ~ Update로 인한 3편에서 말했던 문제가 동일하게 발생한다는 점입니다. 그래서 Select에 WITH(UPDLOCK)을 차감 기능 1번, 3번에 추가하였습니다.(충전 기능 2번과 차감 기능 3번은 동일한 내용으로 충전 기능 2번에도 동일하게 적용 됩니다.)

차감을 병렬적으로 실행해본 결과 문제가 해결되었습니다. 하지만 기존에 만들어 두었던 충전+차감을 병렬로 테스트하는 코드에서 DeadLock이 발생하는 것이 확인 되었고 DeadLock graph는 아래와 같습니다.



=> 헛. 프로세스(트랜잭션)가 하나 더 늘어났을 뿐인데 복잡해 보입니다. 눈을 크게 뜨고 익숙해지기 위해서 그림을 쳐다보면서(농담;; 집중해서 로직을 곰곰이 생각해보면서) 아래와 같이 정리하였습니다.


 

 기능

 설명

 비고

 프로세스 ID 57

 차감 2번

 57번은 포인트 테이블에 U 잠금을 획득하고 충전에 대하여 S 잠금을 요청하고 있습니다. 차감 기능이며 1번에서 U 잠금을 획득 2번에서 S 잠금을 요청하는 것으로 보입니다.


 프로세스 ID 59

 차감 1번

 59번은 포인트 테이블에 대한 U 잠금을 획득하거나 요청하고 있습니다.

 

 프로세스 ID 60

 충전 2번

 충전 테이블에 X 잠금은 충전 기능1번에서만 가능하며 포인트 테이블에 U 잠금을 요청하고 있으므로 충번 1번 기능이후 2번으로 보입니다.

 

=> 일단 그림만 봤을 때 가장 이상한 부분은 Owner에 대한 개념입니다. 동일한 KEY 리소스에 대하여 동시에 Owner를 하는 것처럼 보입니다. 이전에 그림만 보고서도 대부분 유추가 가능할 것이라고 했는데 정확하게 알기 위해서 파일의 내용을 살펴보겠습니다.


<process id="process2e0507088" taskpriority="0" logused="1048" waitresource="KEY: 7:72057594041270272 (1b7fe5b8af93)" waittime="3207" ownerId="1649980" transactionname="user_transaction" lasttranstarted="2017-06-27T12:01:39.290" XDES="0x2d8f3a3b0" lockMode="S" schedulerid="3" kpid="7508" status="suspended" spid="57" sbid="0" ecid="0" priority="0" trancount="2" lastbatchstarted="2017-06-27T12:01:39.297" lastbatchcompleted="2017-06-27T12:01:39.290" lastattention="1900-01-01T00:00:00.290" clientapp=".Net SqlClient Data Provider" hostname="SUNGKKIM-N" hostpid="7928" loginname="SMILEGATE\sungkkim" isolationlevel="read uncommitted (1)" xactid="1649980" currentdb="7" lockTimeout="5000" clientoption1="673185824" clientoption2="128056">

    <executionStack>
     <frame procname="SP명" line="327" stmtstart="21906" stmtend="22334" sqlhandle="

0x03000700805efa59d10a65019ea7000001000000000000000000000000000000000000000000000000000000

">
DeadLock 발생 SQL 구문
    </executionStack>
    <inputbuf>
Proc [Database Id = 7 Object Id = 1509580416]    </inputbuf>
   </process>

   <keylock hobtid="72057594041925632" dbid="7" objectname="TSPURCHASE.dbo.

HoldPoint" indexname="PK_HoldPoint" id="lock2d979fb80" mode="U" associatedObjectId="72057594041925632">
    <owner-list>
     <owner id="process2e0507088" mode="U"/>
    </owner-list>
    <waiter-list>
     <waiter id="process2e1c1a8c8" mode="U" requestType="wait"/>
    </waiter-list>
   </keylock>

=> 일단 Owner에 대해서 알아보면 owner-list에서 requestType의 값으로 잠금을 획득하고 있는지 대기(블럭)인지 알 수 있습니다. 결과적으로 위의 xml 내용에서는 owner하고 있는 프로세스 spid의 값이 57번 것으로 알 수 있습니다.

=> 참고 : xml 파일의 내용 중에 중복된 부분은 제거하였고 살펴볼 필요가 있는 부분을 노란색으로 표시하였습니다.


그럼 Owner에 대한 의문점은 사라졌고 DeadLock이 발생하는 원인을 분석해보면 기존에 Select ~ Update문과 충전 테이블에 대한 X-Lock, S-Lock이 추가되면서 3개의 프로세스(트랜잭션)에서 서로 물고 물리면서 DeadLock이 발생하였습니다. 여기서 알 수 있는 사실은 일부 로직이 동일한 리소스에 잠금을 획득할 경우 병렬로 실행될 경우 DeadLock이 발생할 수 있다는 사실입니다.

다르게 표현을 해보면 충전 기능 1번에 의해서 충전 테이블에는 데이터가 들어가고 트랜잭션 완료되기 전에 차감 기능 2번에서 해당 테이블에 Dirty 데이터를 읽기 때문에 발생하는 현상입니다.


원인 파악을 했으니 해결을 해보려고 충전 테이블에 힌트를 써보았지만 다른 부작용이 너무 많았습니다. 테이블 2개에 잠금이 발생하다보니 DeadLock이 훨씬 빈번하게 일어났고 차감 로직도 복잡하여 일단 접었습니다. 다음으로 생각할 수 있는건 충전 기능 1번 전에 충전 기능 2번을 추가하는 것입니다. 원인이 충전 테이블에 데이터가 들어가는 동시에 다른 트랜잭션에서 해당 테이블에 접근하기 때문입니다. 하지만 해당 방법은 문제를 해결한다는 느낌이 들지 않고 필요없는 로직이 추가되는 느낌이라 접었습니다. 그러다 문득 DeadLock은 어쨌든 잠금에 의해서 발생하기 때문에 충전 기능 1번과 2번을 별도 트랜잭션으로 분리하면 되는 것 아닌가 하는 생각이 들었습니다. 분리를 하였을 경우 기능적으로 문제가 없는지에 대해서 고민을 해보았습니다.


분리했을 경우 문제가 되는 부분은 아래 2가지로 생각이 됩니다.

1. 충전 기능 2번이 실패했을 경우

2. 충전 기능 2번은 실패할 확률이 얼마나 되는지

=> 충전 기능 2번이 실패했을 때의 문제는 포인트 조회와 관련된 부분입니다. 또한 이 기능이 실패할 확률은 하드웨어 적인 부분이나 DB연결과 관련된 문제가 있을 경우에만 실패할 것으로 보입니다. 만약 실패했을 경우 재시도하는 로직까지 넣는다면 문제가 될 만한 확률은 더 작아집니다.


충전 기능 1번과 2번은 분리를 해서 테스트를 진행해보면 예상했던 것처럼 DeadLock이 사라지게 됩니다. 성능적인 측면에서 봤을 때는 DB 연결이 늘어나기 때문에 상대적으로 느려지지만 충전의 성능은 차감에 비하면 절대적으로 빠른 편입니다.


SQL Server DeadLock 시리즈는 이제 이것으로 마무리 하려고 합니다. 오래만에 블로그에 열정을 쏟게 해준 애드센스에게 심심한 감사의 말을 전하며 도대체 언제 달게 해줄꺼니? ㅎㅎㅎ


P.S : UPDLOCK이 생각하는 것처럼 동작하지 않아 원인을 Merge구문 때문이 아닌가 싶어 Select ~ Update, Insert로 동료분이 변경을 해주었는데 결과가 동일하였습니다;; 제가 DeadLock graph를 제대로 보지 않아서 쓸데없는 의심을 했습니다. 이 글은 그 분의 노력으로 탄생하게 되었습니다. 고맙습니다. ㅎㅎ

Posted by resisa
,

3편에서는 테이블 힌트에 대해서 살펴보고 2편에 이어서 DeadLock이 발생하는 예제와 해결 방법에 대해서 이야기 해보도록 하겠습니다.

테이블 힌트 중에 아마도 가장 많이 사용한 것은 WITH(NOLOCK)일 것입니다. 부끄럽게도 작년에 해당 힌트가 ReadUncommitted와 동일하다는 사실을 알았습니다. 조금만 생각해보면 당연히 동일할 수 밖에 없는데 DB개발에 관심이 부족했던 것으로 원인을 돌리며 힌트와 관련된 아래 글을 추천해드립니다.

https://technet.microsoft.com/ko-kr/library/ms187373(v=sql.105).aspx


해당 글을 여유가 있으신 분은 천천히 살펴보시고 3편이 조금 더 풍성하게 보이기 위해서 해당 글을 아래와 같이 정리하였습니다.


 테이블 힌트

 설명 

 새로운 배움 

 비고 

 NOLOCK

 ReadUncommitted와 동일하며 더티 읽기를 허용합니다. 동시성이 높아질 수 있지만 사용자에게 커밋되지 않은 데이터가 제공될 수 있습니다.

 NOLOCK이라는 이름 때문에 잠금이 없을 것이라고 생각하였는데 Sch-S(스키마)잠금 획득합니다.(걸린다고 표현하였는데 획득이 훨씬 그럴듯합니다;;)

 읽기(Select)에 대한 레벨이기 때문에 당연히 삽입, 업데이트, 삭제 작업에 대해서는 해당 옵션이 적용이 되지 않습니다.

 HOLDLOCK

 S-LOCK(공유 잠금)을 트랜잭션이 완료될 때까지 잠금을 유지하여 공유 잠금을 제한적으로 만듭니다.

 SERIALIZABLE 동일

 

 REPEATABLEREAD

 다른 트랜잭션에 의해 수정되었지만 아직 커밋되지 않은 데이터를 읽을 수 없도록 지정합니다.

 현재 트랜잭션이 완료될 때까지 현재 트랜잭션이 읽은 데이터를 다른 트랜잭션이 수정할 수 없도록 지정합니다.

 

 UPDLOCK

 업데이트 잠금을 사용하고 트랜잭션이 완료될 때까지 유지하도록 지정합니다.

 UPDLOCK은 읽기 작업을 위해 행 수준 또는 페이지 수준에서만 업데이트 잠금을 사용합니다.
 UPDLOCK이 TABLOCK과 함께 사용되는 경우 또는 테이블 수준 잠금이 여러 이유로 인해 사용되는 경우, 배타(X) 잠금이 대신 사용됩니다.

 

테이블 힌트가 생각보다 많고 정확하게 알고 쓰지 않으면 부작용으로 고생을 할 수 있습니다;;


참고 : 위의 글에서 많은 힌트를 아래와 같이 분류해주고 있습니다.

SQL Server는 FROM 절의 각 테이블에 대해 다음 각 그룹에서 두 개 이상의 테이블 힌트를 허용하지 않습니다.

  • 세분성 힌트: PAGLOCK, NOLOCK, READCOMMITTEDLOCK, ROWLOCK, TABLOCK, 또는 TABLOCKX.

  • 격리 수준 힌트: HOLDLOCK, NOLOCK, READCOMMITTED, REPEATABLEREAD, SERIALIZABLE


그럼 DeadLock과 관련된 예제를 살펴보겠습니다.


-- 1번 세션

-- 실행1

BEGIN TRAN


DECLARE @Normal bigint = 0

SELECT @Normal=Normal+

FROM Test WHERE ClusteredIndex = 10


WAITFOR DELAY '00:00:10'


UPDATE Test SET Normal=@Normal 

WHERE ClusteredIndex = 10


COMMIT TRAN 

-- 2번 세션

-- 실행2

BEGIN TRAN


DECLARE @Normal bigint = 0

SELECT @Normal=Normal+

FROM Test WHERE ClusteredIndex = 10


UPDATE Test SET Normal=@Normal 

WHERE ClusteredIndex = 10


COMMIT TRAN

=> 이번 예제는 실행 후에 DeadLock이 발생하지는 않습니다. 

구문을 살펴보면 Select에서 ClusteredIndex = 10인 로우의 Normal 컬럼의 값에 +1을 해주고 그 값으로 Update구문을 실행주는 예제입니다. 실행을 해보면 Normal 컬럼에 최종 값이 11이 됩니다. 하지만 실제로 원하는 값은 12입니다. 원인을 파악하기 전에 트랜잭션 IsolationLevel에 따라 발생하는 3가지 현상을 정리한 내용을 살펴보겠습니다.


낮은 단계의 트랜잭션 고립화 수준 이용시 발생하는 현상 3가지

- Dirty Read (=Uncommitted Dependency)

커밋되지 않은 수정 중인 데이터를 다른 트랜잭션에서 읽을 수 있도록 허용할 때 발생

- Non-Repeatable Read (=Inconsistent Analysis)

한 트랜잭션 내에서 같은 쿼리를 두 번 수행할 때 그 사이에 다른 트랜잭션이 값을 수정 또는 삭제함으로써 두 쿼리의 결과가 상이하게 나타나는 비 일관성 발생

- Phantom Read

한 트랜잭션 안에서 일정 범위의 레코드를 두 번 이상 읽을 때첫 번째 쿼리에서 없던 레코드가 두 번째 쿼리에서 나타나는 현상이는 트랜잭션 도중 새로운 레코드가 삽입되는 것을 허용하기 때문에 나타남 

=> 위의 예제는 Dirty Read일까요? Non-Repeatable Read일까요? 처음에 단순히 생각했을 때는 Dirty한 것을 읽었다고 생각했지만 전제 조건을 자세히 보면 '커밋되지 않은 수정 중인 데이터'입니다. 실행2에서 Select구문은 Dirty한 것이 아니라 아직 수정이 안된 정확한 데이터를 읽은 것입니다. 원인은 Non-Repeatable Read 현상입니다.

=> SQL Server에 기본 IsolationLevel은 ReadCommitted이고 커밋이 된 데이터만 읽는 것이 아니라 커밋되기 전의 수정 중이지 않은 데이터는 그 순간에 정상적인 데이터이기 때문에 당연히 읽을 수 있는 것입니다.


해당 문제를 해결하기 위해서 IsolationLevel을 올려 REPEATABLEREAD로 변경하거나 테이블 힌트를 주어서 실행을 해봅니다. 결과는 아래와 같습니다.



=> 윽.. DeadLock이 발생하였습니다. 그림이 익숙하지 않다면 표로 시간 순서 상으로 정리해보면 이해가 더 빨리 되실겁니다.


 시간순서 

 세션1(프로세스ID 52)

 세션2(프로세스ID 53)

 1

 Select 구문 : S-LOCK 획득 

 

 2

 

 Select 구문 : S-LOCK 획득

 3

 

 Update 구문 : X-LOCK 블럭

 4

 Update 구문 : X-LOCK 블럭

 

=> 시간순서 3에서 Update구문이 블럭이 됩니다. 이유는 REPEATABLEREAD 힌트의 '새로운 배움'을 보면 알 수 있는데 세션1에서 Select문으로 읽은 데이터를 세션2에서 세션1의 트랜잭션이 완료되거나 롤백될때까지 업데이트 할 수 없기 때문입니다.

=> 시간순서 4로 가면 세션1 입장에서도 시간순서 3과 마찬가지로 블럭이 됩니다. 세션1, 세션2 중 하나의 트랜잭션이 완료되거나 롤백되어야 하는데 서로 블럭되기 때문에 DeadLock 상태가 됩니다. 물론 똑똑한 SQL Server가 이를 감지하고 뒤늦게 실행된 세션1을 중지시킵니다.


그러면 Non-Repeatable Read가 발생하지 않고 DeadLock도 발생하지 않으려면 어떻게 해야할까요? 2편에서 보았던 잠금의 호환성을 간략화해서 살펴보면 해답이 있습니다.


잠금의 호환성 (Lock Compatibility)

Requested mode

Existing granted mode

 

S

U

X

Shared (S)

Yes

Yes

No

Update (U)

Yes

No

No

Exclusive (X)

No

No

No

(테이블 출처 : http://msdn.microsoft.com/en-us/library/ms172925.aspx)


=> S-LOCK이 걸렸던 부분을 U-LOCK으로 변경한다면 시간순서 2에서 Select구문이 블럭됩니다. 세션1의 트랜잭션이 완료되거나 롤백 될때까지 다음 구문 실행이 불가능하기 때문에(블럭) DeadLock에 빠질 수도 없고 다른 트랜잭션에서 수정이 발생이 완료되거나 롤백이 된 이후에 데이터를 읽기 때문에 Non-Repeatable Read도 발생하지 않습니다.

=> 잠금을 S-LOCK -> U-LOCK으로 올려서 성능에 문제가 발생하는 것이 아닌가 생각하실 수도 있는데 잠금의 종류(KEY, PAG, TAB)에 대한 잠금 설정(획득)이기 때문에 실상황에서는 문제가 되지 않을 것으로 생각됩니다. 더군다나 DB의 입장에서는 데이터의 무결성이 무엇보다 중요합니다.


추가적으로 개발 테스트 코드에서 병렬 테스트를 하기 위한 샘플 코드 첨부합니다.

Task.WaitAll(Enumerable.Range(0, 10).Select(t => 

   Task.Run(() =>

    {

        // 비지니스 로직

    })).ToArray());


오랜만에?! 시리즈로 써보았는데 글의 내용보다는 테스트를 해서 다시 확인하는 과정에서 시간이 오래 걸렸습니다. 정확한 정보(팩트)를 전달하려다 보니 사실위주의 당연한 이야기를 한것 같아 아 별거 없네 이런 생각도 들었지만 1편 보다는 2편, 2편 보다는 3편이 더 나은 것?! 같아 대충 만족하며 마무리 하려고 합니다.


Posted by resisa
,

또?! 오랜만입니다 ㅎㅎ 지인이 애드센스 등록을 하셔서 저도 시도를 해보았더니 콘텐츠 부족으로 실패하여 이렇게 새로운 글을 쓰고 있습니다.

어떤 내용을 쓸까 고민을 하다가 블로그를 정리하면서 예전에 썼던 글 중에 그 당시 궁금했던 내용에 대한 답변을 해보고자 합니다.
(벌써 7년이 지났다니 시간이 참 빠릅니다;;)

TransactionScope 그리고 Stored Procedure (2010. 07. 25)
출처: http://resisa.tistory.com/110 [심플하게~]

(중략)...

1. 한 가지 의문점은 SP안에서는 트랜잭션의 Scope 범위(TransactionScopeOption) 지정하는 부분은 없어보이지만 IsolationLevel 대해서는 지정을   있습니다또한 TransactionScope에서도 IsolationLevel 대해서 지정할  있습니다그래서 IsolationLevel 따른 LTM SQLTransaction 관계가 어떻게 될지도 살짝 궁금해집니다. 하지만 실질적으로 이러한 것을 프로젝트에서 정확하게 알고 사용하는 개발자가 얼마나 될지도 의문이며 IsolationLevel 트랜잭션 사이의 잠금(lock) 대한 것이기 때문에 2. 성능보다는 안전성을 중요시하는 우리 나라의 대부분의 프로젝트에서는 ReadCommitted 사용하는 것이 개발자의 정신건강에 이로워 보입니다. ^^

예전에 썼던 글에 은근히 잘못된 내용이 있습니다;;  이유는 이해부족 입니다;;
저는 새로운 기술을 습득하는 과정에서 '정의'를 자신의 방식으로 표현하고 증명하는 과정을 반복합니다. '정의'와 '증명'을 잘못하면 위와 같이 잘못된 글이 나오기도 하지만 경험이 붙으면 증명하는 시간이 짧아지고 단순 실수도 줄어 이해하는 시간이 짧아지고 자신의 표현 방식으로 인하여 오랫동안 기억되는 장점이 있는 방식이라고 생각됩니다. 그럼 잘못된 부분부터 수정해보겠습니다.

=> 1번에서는 개념에 대해서 잘못 설명하고 있습니다. TransactionScopeOption은 TransactionScope클래스의 파라미터로 DB(SP)에는 없는 속성입니다.

=> 2번 대부분의 프로젝트에서 ReadCommitted로 설정할 것이라는 이유는 MSSQL의 기본 IsolationLevel이 ReadCommitted이기 때문입니다. 이 당시에는 IsolationLevel에 대한 이론적인 것만 알고 있었기 때문에 이런 결론을 냈었는데 업그레이드된?! 지금은 대부분의 프로젝트에서는 ReadUncommitted를 사용할 것이라고 생각합니다. 왜냐하면 ReadCommitted로 설정을 하면 DeadLock이 발생하는 구간이 많이 있을 수 있습니다. 그렇기 때문에 직접적으로 ReadUncommitted를 지정하지 않았더라도 이와 동일한 WITH(NOLOCK) 힌트를 많이 사용했을 것이라고 추측됩니다.

그럼 본론으로 들어가서 노란색 부분에 대한 이야기를 풀어보겠습니다.

먼저 트랜잭션을 아래와 같이 2가지 형태로 구분합니다.
1. 로컬 트랜잭션(SQL Transaction)
2. 분산 트랜잭션(DTC Transaction)

1. 로컬 트랜잭션을 세부화 하면 아래와 같이 나눌 수 있습니다.
1.1. TM(Transaction Manager)이 관여하는 SQL Transaction
1.2 TM이 관여하지 않는 SQL Transaction

개념적인 측면에서는 TM의 관여 여부로 나눌 수 있으며 개발적인 측면에서는 프로그램에서 트랜잭션을 관리하는지 DB에서 즉 SP에서 트랜잭션을 관리 여부로 나눌 수 있습니다.

다시 노란색 부분을 보면 SP에서 트랜잭션을 관리하는 부분들이 프로그램에서 트랜잭션을 관리하는 것과 합쳐졌을 경우에 트랜잭션 관리(Connection, IsolationLevel)에 대한 궁금증이였습니다.

프로그램에서 트랜잭션 관리를 하는 방법은 아래와 같습니다.
1. ADO.NET(System.Data.SqlClient.SqlConnection)를 사용하여 직접 BeginTransaction()를 호출하여 사용
2. System.Transactions.TransactionScope를 사용

트랜잭션을 관리하는 1번, 2번 방법의 공통점은 프로그램에서 트랜잭션을 관리하기 때문에 TM이 트랜잭션을  관리한다는 점입니다. 차이점이 바로 이 글의 핵심이 되는 답변으로 IsolationLevel과 관련되어 있습니다. TransactionScope에 IsolationLevel을 지정하여 사용할 때 SP의 IsolationLevel을 변경할 수 없다는 것입니다. IsolationLevel에 대한 위의 네임스페이스를 살펴보면 아래와 같습니다.

1. System.Data.SqlClient.SqlConnection - System.Data.IsolationLevel
2. System.Transactions.TransactionScope - System.Transactions.IsolationLevel

조심스럽게 예측해보면 TransactionScope의 트랜잭션은 DB 트랜잭션이라기보다는 프로그램에서 발생하는 트랜잭션(여기서는 DB 트랜잭션을 포함하는 상위의 트랜잭션의 개념으로 이해)이라고 할 수 있고 IsolationLevel은 트랜잭션 사이의 격리성이기 때문에 프로그램에서 발생하는 트랜잭션에 대한 격리성이지 DB 트랜잭션에 대한 격리성이 아니기 때문에 DB(SP) IsolationLevel을 변경할 수 없는 것입니다.

결론을 맺으면 프로그램에서 DB(SP) 트랜잭션 관리(IsolationLevel)를 하고 싶으면 SqlConnection을 사용하여 직접 트랜잭션을 발생(BeginTransaction())시켜야하며 TransactionScope을 통해서는 DB(SP) IsolationLevel까지는 관리할 수 없다는 것입니다.

Posted by resisa
,
COM+ Transaction과 System.Transaction 네임스페이스 안의 TransactionScope의 트랜잭션 관점에서의 차이점을 어떻게 알고 계시나요? 저는 COM+ Transaction은 무조건 분산 트랜잭션으로 TransactionScope은 ConnectionString에 따라서 로컬 또는 분산 트랜잭션을 사용하는 것으로 알고 있었습니다. 그런데 최근에 COM+ 관련 테스트를 하다가 재미있는 점을 발견하였습니다. COM+ Transaction도 로컬 트랜잭션으로 사용되는 것과 같은 현상(?!)을 보게 되었습니다. 그러면 저에게 이러한 혼란을 준 현상을 SQL Profiler과 Component Services로 트랜잭션을 모니터링 해보도록 하겠습니다.

테스트 환경
 - .NET Framework 4.0
 - Windows 7 64bit Ultimate
 - MS SQL 2008 R1(local에 설치)

먼저 COM+ 관련 예제 코드는 아래와 같습니다.
[Transaction(TransactionOption.Required)]
public class COMTxObject : ServicedComponent
{
    string connStr = "Data Source=(local);Initial Catalog=EFWithSQL;Integrated Security=True;";
    string connStr2 = "Data Source=(local);Initial Catalog=EFWithSQL;Integrated Security=true;";

    [AutoComplete(true)]
    public void SQL_Select()
    {
        string name = Guid.NewGuid().ToString();

        string query = @"
select top 1 [id] from [dbo].[Entity1Set]
";

        using (SqlConnection conn = new SqlConnection(connStr))
        {
            conn.Open();

            SqlCommand cmd = new SqlCommand(query, conn);
            object result = cmd.ExecuteScalar();
            conn.Close();
        }
    }

    [AutoComplete(true)]
    public void SQL_Insert()
    {
        string name = Guid.NewGuid().ToString();

        string query = @"
insert [dbo].[Entity1Set]([Name])
values ('" + name + @"')
select [Id]
from [dbo].[Entity1Set]
where @@ROWCOUNT > 0 and [Id] = scope_identity()
        ";

        using (SqlConnection conn = new SqlConnection(connStr))
        {
            conn.Open();
            SqlCommand cmd = new SqlCommand(query, conn);
            int result = cmd.ExecuteNonQuery();
            conn.Close();
        }

        SQL_Insert1_1();
        
    }

    void SQL_Insert1_1()
    {
        string name = Guid.NewGuid().ToString();

        string query = @"
insert [dbo].[Entity1Set]([Name])
values ('" + name + @"')
select [Id]
from [dbo].[Entity1Set]
where @@ROWCOUNT > 0 and [Id] = scope_identity()
        ";

        using (SqlConnection conn = new SqlConnection(connStr))
        {
            conn.Open();
            SqlCommand cmd = new SqlCommand(query, conn);
            int result = cmd.ExecuteNonQuery();
            conn.Close();
        }
    }

    [AutoComplete(true)]
    public void SQL_Insert2()
    {
        string name = Guid.NewGuid().ToString();

        string query = @"
insert [dbo].[Entity1Set]([Name])
values ('" + name + @"')
select [Id]
from [dbo].[Entity1Set]
where @@ROWCOUNT > 0 and [Id] = scope_identity()
        ";

        using (SqlConnection conn = new SqlConnection(connStr))
        {
            conn.Open();
            SqlCommand cmd = new SqlCommand(query, conn);
            int result = cmd.ExecuteNonQuery();
            conn.Close();
        }

        SQL_Insert2_1();
    }

    void SQL_Insert2_1()
    {
        string name = Guid.NewGuid().ToString();

        string query = @"
insert [dbo].[Entity1Set]([Name])
values ('" + name + @"')
select [Id]
from [dbo].[Entity1Set]
where @@ROWCOUNT > 0 and [Id] = scope_identity()
        ";

        using (SqlConnection conn = new SqlConnection(connStr2))
        {
            conn.Open();
            SqlCommand cmd = new SqlCommand(query, conn);
            int result = cmd.ExecuteNonQuery();
            conn.Close();
        }
    }
}
=> DB는 Entity1Set이라는 테이블에 ID, Name을 컬럼으로 가지고 있으며 ID의 경우에는 int형의 IDENTITY로 지정하여 자동으로 증가하게 되어 있습니다. COM+ 이기 때문에 ServicedComponents를 상속받고 있으며 해당 클래스 어트리뷰트로 TransactionOption이 Required로 지정된 Transaction 어트리뷰트가 지정되어 있습니다. 세 개의 메서드가 존재하는데 하나는 조회를 하는 쿼리이며 두 개는 ConnectionString이 동일한 상태에서의 삽입이고(SQL_Insert()), 다른 하나는 ConnectionString이 다른 상태에서의 삽입(SQL_Insert2())입니다. 각각 메서드 위에는 자동으로 Complete를 지정해주는 AutoComplete라는 어트리뷰트가 선언되어 있습니다. (참고 : COM+에서는 수동으로 Commmit, Rollback를 해주기 위해서 ContextUtil이라는 클래스를 사용하기도 합니다.)
그리고 해당 어셈블리를 강력한 이름으로 서명을 해주고 AssemblyInfo.cs파일에 ComVisible을 true로 변경해 준 후에 빌드를 하고 Regsvcs.exe를 사용해서 COM+ 카달로그에 등록을 해주었습니다.
그러면 조회 메소드(SQL_Select)를 실행하였습니다.
1. SQL Profiler 결과
=> 헛.. 이상합니다. COM+는 분산 트랜잭션을 사용하기 때문에 DTCTransaction이 보여야 하는데 보이지 않습니다.

2. Component Services 결과
=> 헛.. 역시 이상합니다. COM+ Transaction이 발생하였는데 DTCTransaction이 보이지가 않습니다.

이번에는 조회 메소드 안에서 강제로 예외를 발생시켜 보았습니다.
1. SQL Profiler 결과
=> 드디어 DTCTransaction이 보입니다. Rollback이 정상적으로 됩니다.

2. Component Services 결과
=> 역시 Aborted된 트랜잭션의 개수가 보입니다. 헛헛.. 그렇다면 COM+ 트랜잭션이 정상적으로 Commit이 될 경우에는 로컬 트랜잭션을 사용하고 Rollback이 될 경우에는 분산 트랜잭션을 사용한다는 말입니다. 지금까지 COM+ Transaction은 분산 트랜잭션을 사용해서 느리다라고 알 고 있었는데 제가 먼가 새로운 것을 발견한걸까요? ㅎㅎㅎ;;;
여기서 몇 가지 테스트를 더 해보기 하였습니다.
(참고 : Regsvcs로 컴포넌트를 등록해줄 경우에도 DTC를 사용하여 Committed 개수가 증가합니다. 따라서 모든 테스트 전에는 DTC Service를 멈추었다가 다시 시작해주었습니다.)

먼저 로컬 트랜잭션과 분산 트랜잭션 과연 성능의 차이는 얼마나 있는 것일까요? (성능은 환경적인 요인에 따라 다르게 측정되기 때문에 여기서는 단순한 비교(?!)를 통해서 대략 이렇다 정도로만 테스트를 합니다.)
이번에는 조금 더 많이 사용해 본 TransactionScope클래스를 사용해서 테스트를 해보았습니다.
코드는 아래와 같습니다.
Stopwatch watch = new Stopwatch();
            
for (int i = 0; i < 1000; i++)
{
    using (TransactionScope scope = new TransactionScope(System.Transactions.TransactionScopeOption.Required))
    {
        var helper = new SqlHelper();
        watch.Start();
        helper.SQL_Insert();
        //helper.SQL_Insert2();
        scope.Complete();
    }
    watch.Stop();
}
=> SqlHelper클래스는 이전에 사용한 COMTxObject클래스에서 COM+관련 부분만을 제거한 클래스입니다. 주석 처리된 부분을 보면 해당 테스트가 어떻게 될 것인지 아실 수 있습니다. 먼저 동일한 ConnectionString으로 삽입되는 SQL_Insert()메소드를 호출해보고 ConnectionString이 다른 SQL_Insert2()메소드를 호출하여 실행시켜서 로컬, 분산 트랜잭션의 결과를 비교해 보는 것입니다. 실행 시간을 측정하기 위해서 Stopwatch클래스를 사용하였으며 COM+의 객체 생성시간이 더 오래 걸리기 때문에 트랜잭션과 관련이 있는 메소드의 실행시간만을 측정하기 위해서 메소드 실행 전 후로 Start, Stop 메소드를 호출해주고 있습니다.
먼저 로컬 트랜잭션(1000번)으로 처리하였을 경우에는 대략 3~5초 정도의 시간이 걸립니다. 분산 트랜잭션으로 처리하였을 경우에는 대략 6~9초 정도의 시간이 걸렸습니다. SQL Profiler에서는 로컬시에는 TM(Transaction Manger) 분산시에는 DTCTransaction을 사용하는 것으로 보였고 Component Service에서는 로컬 트랜잭션일 경우에는 아무런 반응이 없다가 분산 트랜잭션을 사용할 경우에 아래와 같이 Commited 숫자가 증가하였습니다.
=> 총 5번을 실행(1000*5) 한 결과입니다.

이번에는 COM+ Transaction으로 동일한 테스트를 해보았습니다.
코드는 아래와 같습니다.
Stopwatch watch = new Stopwatch();

for (int i = 0; i < 1000; i++)
{
    var com = new COMPlusLibrary.EFCOMTxObject();
    watch.Start();
    com.SQL_Insert();
    //com.SQL_Insert2();
    watch.Stop();
}
=> SQL_Insert()를 실행시켰을 때 SQL Profiler에서는 TM만 보이며 Component Service에서 역시 아무런 변화가 없습니다. 그런데 로컬 트랜잭션 이였다고 말하기에 한 가지 이상한 점이 있습니다. 실행시간이 조금 더 걸린다는 겁니다. 거의 TransactionScope을 분산 트랜잭션으로 처리하는 것과 비슷한 시간입니다. SQL_Insert2()를 실행시켰을 때 SQL Profilier에서는 DTCTransaction이 보이며 시간은 더 오래 걸립니다. 그래서 해당 부분을 다시 여러번 실행시켜 실행시간을 다시 측정해보았습니다.
   COM+ Transaction TransactionScope 
 로컬 트랜잭션  4.4~6.3  3.7~5.2
 분산 트랜잭션  7.3~10.4  6.1~9.2
=> 1000번씩 실행되는 구문을 20번 실행시켜 보고 최소값과 최대값을 제외하고 실행 시간의 범위를 표시해보았습니다. 여기서는 실행 모드(Ctrl + F5)로 측정한 값입니다. 로컬이든 분산이든 우리가 이미 알고 있듯이 COM+ Transaction보다는 TransactionScope의 성능이 더 뛰어나다고 말할 수 있습니다. (객체의 생성시간을 제외하고 측정한 시간이기 때문에 COM+ Transaction에게 더 유리한(?!) 측정이였습니다.)

2011-02-18 수정내용
성능 관련 측정을 다시 해보니 문제가 될만한 의심되는 부분이 있었습니다. 정확한 결과는 정확한 확인 이후에 다시 올리도록 하겠습니다.


COM+ Transaction 사용시에 로컬 트랜잭션을 사용한다는 것은 DTC를 사용하지 않는다는 말이 될 수도 있다는 생각에 DTC Service를 종료한 이후에 COM+ TransactionOption을 주고 실행해보았습니다. 아래와 같은 결과를 얻을 수 있었습니다.
 TransactionOption DTC 사용 여부 
 Disable  X
 Not Supported  X
 Supported  X
 Required  O
 RequiredNew  O
=> 물론 여기서 Supported 옵션은 해당 클래스(COMTxObject)의 메소드가 실행되기 전에 트랜잭션이 발생된 이후에 실행되었다면 이전 트랜잭션에 참여하기 때문에 DTC를 사용할 수도 있습니다. DTC를 사용해야지만 트랜잭션이 발생한다는 것을 알 수 있습니다. 또한 DTC를 사용했다고 해서 꼭 DTCTransaction이 발생하는 것은 아니라는 점도 알 수 있습니다.

결론을 내기 전에 지금까지 사용된 용어들을 정리해보는 차원에서 유수석님의 글을 참조 하겠습니다.
http://www.simpleisbest.net/archive/2005/08/23/208.aspx

 분산 트랜잭션이란 네트워크에 분산되어 있는 자원들에 대해 트랜잭션을 수행하는 것을 말한다. 예를 들어, 어떤 애플리케이션이 SQL 서버와 오라클에 데이터를 트랜잭션 하에서 수행해야 한다면 분산 트랜잭션을 필요로 할 것이다. 대개의 경우 분산 트랜잭션은 턱시도, 티맥스, 엔트라와 같은 TP 모니터나 COM+, EJB 등과 같은 컴포넌트 기반 미들웨어가 그 기능들을 제공한다.

분산 트랜잭션의 반대되는 개념으로서 로컬 트랜잭션은 단일 자원(데이터베이스)에 대한 커밋과 롤백을 수행하며 1-phase 커밋으로서 트랜잭션을 수행한다. 한편 분산 트랜잭션의 핵심은 2-phase 커밋으로 볼 수 있다. 커밋(Commit)과 취소(Abort)(분산 트랜잭션에서는 롤백(rollback)보다는 abort라는 용어를 사용한다)를 수행하는데 두 단계를 거친다는 말이다. 첫 번째 phase는 준비 단계(prepare phase)로서, 데이터베이스는 커밋을 위한 모든 준비를 수행한다. 분산 트랜잭션에 참여한 모든 데이터베이스가 준비 단계를 성공한 후에야 두 번째 phase인 커밋 단계가 수행되는 것이다. 만약 분산 트랜잭션에 참여한 어느 한 데이터베이스라도 준비 단계를 실패한다면 두 번째 phase는 커밋이 아닌 취소를 수행하게 될 것이다.

이렇게 각 데이터베이스에게 준비 혹은 커밋/취소의 두 단계를 수행하도록 트랜잭션을 제어하는 트랜잭션 관리자를 TM (Transaction Manager)이라 부르며 이는 MSDTC(Microsoft Distributed Transaction Coordinator)가 담당한다. 지금까지 단순히 분산 트랜잭션에 참여하는 ‘데이터베이스’라고 참조했지만 데이터베이스 외에 다른 자원들도 분산 트랜잭션에 참여할 수 있다. 대표적인 예로 MSMQ, COM+의 Shared Property가 이에 해당된다. 따라서 분산 트랜잭션에서는 트랜잭션에 참여하는 각 자원에 대한 관리를 맡는 RM(Resource Manager)이 존재한다. RM의 대표적인 예는 오라클, SQL 서버와 같은 데이터베이스를 들 수 있다.

요약해 보면, COM+ 컴포넌트의 분산 트랜잭션의 관리는 MSDTC와 같은 TM을 통해 수행하며 TM은 트랜잭션에 참여한 RM들(SQL 서버, 오라클, MSMQ 등)에게 2-phase 커밋을 수행한다는 점이다.


지금까지의 여러 가지 테스트 결과를 확인해보면 COM+ Transaction에서도 로컬과 분산 트랜잭션이 모두 발생하며 동일한 ConnectionString일 경우에 정상적으로 Commit이 될 경우에는 로컬 트랜잭션으로 Rollbakc이 될 경우에는 분산 트랜잭션을 사용하는 것으로 알 수 있습니다. 하지만 COM+ Transaction은 TransactionScope를 사용하는 경우보다 성능적인 면에서 떨어지며 TransactionScope의 경우에 동일한 ConnectionString일 경우에 Commit, Rollback의 여부에 상관없이 모두 로컬 트랜잭션이 발생하며 MSDTC 또한 사용하지 않습니다.
Posted by resisa
,