MySQL에서의 잠금 메커니즘과 격리 수준: 공유 잠금(S LOCK)과 배타 잠금(EXCLUSIVE LOCK)의 동작 및 문제 발생 시나리오

데이터베이스 관리 시스템(DBMS)에서 트랜잭션의 무결성과 일관성을 보장하기 위해 다양한 잠금 메커니즘과 트랜잭션 격리 수준이 사용됩니다. MySQL은 이러한 잠금 메커니즘과 격리 수준을 통해 다중 사용자 환경에서 발생할 수 있는 데이터 충돌과 무결성 문제를 방지합니다. 이 글에서는 MySQL의 공유 잠금과 배타 잠금이 어떻게 작동하는지, 그리고 격리 수준에 따라 어떤 문제가 발생할 수 있는지에 대해 깊이 있게 살펴보겠습니다. 이를 위해 각 격리 수준에서 발생할 수 있는 문제를 예제와 함께 설명하고, 이를 테스트하기 위한 TypeScript 코드를 제공하겠습니다.

잠금 메커니즘의 기본 개념

잠금(lock)은 트랜잭션이 특정 데이터에 접근할 때, 다른 트랜잭션이 해당 데이터에 접근하지 못하도록 하는 메커니즘입니다. 잠금은 데이터의 무결성을 유지하고, 여러 트랜잭션이 동시에 같은 데이터를 수정하려 할 때 발생할 수 있는 충돌을 방지합니다.

1. 공유 잠금 (S LOCK)

공유 잠금은 여러 트랜잭션이 동일한 자원(레코드)을 동시에 읽을 수 있도록 허용합니다. 공유 잠금이 걸린 상태에서는 다른 트랜잭션이 해당 자원에 대해 배타 잠금을 걸고 수정하는 것을 허용하지 않습니다. 즉, 여러 트랜잭션이 같은 데이터를 읽을 수는 있지만, 수정은 불가능한 상태를 유지합니다. 공유 잠금은 데이터를 읽는 동안 다른 트랜잭션이 데이터를 변경할 수 없도록 하여 데이터의 일관성을 보장합니다.

2. 배타 잠금 (EXCLUSIVE LOCK)

배타 잠금은 특정 자원(레코드)에 대해 오직 하나의 트랜잭션만이 접근하여 수정할 수 있도록 하는 잠금입니다. 배타 잠금이 걸린 레코드는 다른 트랜잭션이 접근할 수 없으며, 공유 잠금을 포함한 다른 모든 잠금 요청을 대기 상태로 만듭니다. 이는 트랜잭션이 데이터를 안전하게 수정할 수 있도록 보장합니다.

트랜잭션 격리 수준 (Transaction Isolation Levels)

격리 수준은 트랜잭션이 서로의 중간 상태를 얼마나 볼 수 있는지를 결정하는 설정입니다. 이는 데이터베이스의 일관성을 보장하면서도 동시에 성능을 최적화하는 데 중요한 역할을 합니다. MySQL에서는 4가지 주요 격리 수준이 제공되며, 각 격리 수준에서 발생할 수 있는 문제를 아래에 설명하겠습니다.

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

특징: 가장 낮은 격리 수준으로, 트랜잭션이 커밋되지 않은 데이터를 읽을 수 있습니다. 이 수준에서는 데이터에 대한 잠금이 거의 적용되지 않습니다. 공유 잠금이나 배타 잠금이 발생할 가능성이 적고, 트랜잭션 간의 간섭이 허용됩니다.

발생할 수 있는 문제: 더러운 읽기 (Dirty Read)

더러운 읽기란 하나의 트랜잭션이 아직 커밋되지 않은 다른 트랜잭션의 데이터를 읽을 수 있는 상황을 말합니다. 예를 들어, 트랜잭션 A가 데이터를 수정하고 커밋하지 않은 상태에서 트랜잭션 B가 이 데이터를 읽는 경우입니다. 만약 트랜잭션 A가 롤백된다면, 트랜잭션 B는 잘못된 데이터, 즉 "더러운 데이터"를 읽게 되는 것입니다. 이 문제는 데이터의 무결성을 심각하게 훼손할 수 있습니다.

2. READ COMMITTED (커밋된 상태 읽기)

특징: 이 격리 수준에서는 커밋된 데이터만 읽을 수 있습니다. 트랜잭션이 데이터를 읽을 때는 공유 잠금이 걸리며, 데이터 수정 시에는 배타 잠금이 적용됩니다. 이로 인해 더러운 읽기는 방지되지만, 다른 종류의 문제가 발생할 수 있습니다.

발생할 수 있는 문제: 반복 불가능한 읽기 (Non-repeatable Read)

반복 불가능한 읽기는 동일한 트랜잭션 내에서 같은 쿼리를 두 번 실행할 때, 서로 다른 결과가 반환되는 상황을 의미합니다. 예를 들어, 트랜잭션 A가 특정 레코드를 읽은 후, 트랜잭션 B가 이 레코드를 수정하고 커밋한 상태에서, 트랜잭션 A가 다시 같은 레코드를 읽으면 다른 결과가 나올 수 있습니다. 이는 동일한 트랜잭션 내에서 일관된 데이터를 보장하지 못하는 문제를 초래할 수 있습니다.

3. REPEATABLE READ (반복 가능한 읽기)

특징: 이 격리 수준에서는 트랜잭션이 시작된 이후의 모든 읽기 작업에서 동일한 결과를 반환하도록 보장됩니다. 이는 팬텀 읽기(Phantom Read)를 방지하기 위해 인덱스 기반의 갭 잠금(Gap Lock)이 사용됩니다. 이 격리 수준은 MySQL의 기본 설정입니다.

발생할 수 있는 문제: 팬텀 읽기 (Phantom Read)

팬텀 읽기는 한 트랜잭션 내에서 동일한 쿼리를 반복할 때, 새로운 행이 삽입되거나 기존 행이 삭제되어 결과가 달라지는 상황을 의미합니다. 예를 들어, 트랜잭션 A가 조건에 맞는 모든 레코드를 읽고 있는 동안, 트랜잭션 B가 새로운 레코드를 삽입하거나 기존 레코드를 삭제하고 커밋하면, 트랜잭션 A가 다시 쿼리를 실행했을 때 다른 결과가 반환될 수 있습니다. 팬텀 읽기는 데이터 일관성에 문제를 야기할 수 있습니다.

4. SERIALIZABLE (직렬화 가능)

특징: 가장 높은 격리 수준으로, 트랜잭션이 직렬화된 것처럼 동작합니다. 모든 읽기 작업에도 잠금이 걸리며, 동시성이 크게 제한됩니다. 이 격리 수준에서는 데이터의 일관성을 가장 잘 보장하지만, 성능에 큰 영향을 줄 수 있습니다.

발생할 수 있는 문제: 성능 저하 (Performance Degradation)

성능 저하는 높은 격리 수준에서 필연적으로 발생할 수 있는 문제입니다. SERIALIZABLE 격리 수준에서는 모든 트랜잭션이 직렬화된 것처럼 동작하기 때문에, 동시성 처리 성능이 크게 저하될 수 있습니다. 트랜잭션 간의 간섭이 최소화되면서 데이터의 일관성을 최대한 보장할 수 있지만, 시스템이 동시에 처리할 수 있는 트랜잭션 수가 줄어들게 됩니다. 이는 특히 트랜잭션이 많은 대규모 시스템에서 심각한 성능 문제로 이어질 수 있습니다.

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

아래는 각 격리 수준에서 발생할 수 있는 문제를 이해하기 위한 테스트 시나리오입니다. 이를 통해 잠금 메커니즘과 격리 수준이 어떻게 상호작용하는지 확인할 수 있습니다.

1. 테스트 테이블 및 인덱스 생성

모든 테스트에서 사용할 테이블과 인덱스를 먼저 생성합니다.

typescript
MySQL에서의 잠금 메커니즘과 격리 수준: 공유 잠금(S LOCK)과 배타 잠금(EXCLUSIVE LOCK)의 동작 및 문제 발생 시나리오

잠금 메커니즘의 기본 개념

1. 공유 잠금 (S LOCK)

2. 배타 잠금 (EXCLUSIVE LOCK)

트랜잭션 격리 수준 (Transaction Isolation Levels)

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

발생할 수 있는 문제: 더러운 읽기 (Dirty Read)

더러운 읽기란 하나의 트랜잭션이 아직 커밋되지 않은 다른 트랜잭션의 데이터를 읽을 수 있는 상황을 말합니다. 예를 들어, 트랜잭션 A가 데이터를 수정하고 커밋하지 않은 상태에서 트랜잭션 B가 이 데이터를 읽는 경우입니다. 만약 트랜잭션 A가 롤백된다면, 트랜잭션 B는 잘못된 데이터, 즉 "더러운 데이터"를 읽게 되는 것입니다. 이 문제는 데이터의 무결성을 심각하게 훼손할 수 있습니다.

2. READ COMMITTED (커밋된 상태 읽기)

발생할 수 있는 문제: 반복 불가능한 읽기 (Non-repeatable Read)

반복 불가능한 읽기는 동일한 트랜잭션 내에서 같은 쿼리를 두 번 실행할 때, 서로 다른 결과가 반환되는 상황을 의미합니다. 예를 들어, 트랜잭션 A가 특정 레코드를 읽은 후, 트랜잭션 B가 이 레코드를 수정하고 커밋한 상태에서, 트랜잭션 A가 다시 같은 레코드를 읽으면 다른 결과가 나올 수 있습니다. 이는 동일한 트랜잭션 내에서 일관된 데이터를 보장하지 못하는 문제를 초래할 수 있습니다.

3. REPEATABLE READ (반복 가능한 읽기)

발생할 수 있는 문제: 팬텀 읽기 (Phantom Read)

팬텀 읽기는 한 트랜잭션 내에서 동일한 쿼리를 반복할 때, 새로운 행이 삽입되거나 기존 행이 삭제되어 결과가 달라지는 상황을 의미합니다. 예를 들어, 트랜잭션 A가 조건에 맞는 모든 레코드를 읽고 있는 동안, 트랜잭션 B가 새로운 레코드를 삽입하거나 기존 레코드를 삭제하고 커밋하면, 트랜잭션 A가 다시 쿼리를 실행했을 때 다른 결과가 반환될 수 있습니다. 팬텀 읽기는 데이터 일관성에 문제를 야기할 수 있습니다.

4. SERIALIZABLE (직렬화 가능)

발생할 수 있는 문제: 성능 저하 (Performance Degradation)

성능 저하는 높은 격리 수준에서 필연적으로 발생할 수 있는 문제입니다. SERIALIZABLE 격리 수준에서는 모든 트랜잭션이 직렬화된 것처럼 동작하기 때문에, 동시성 처리 성능이 크게 저하될 수 있습니다. 트랜잭션 간의 간섭이 최소화되면서 데이터의 일관성을 최대한 보장할 수 있지만, 시스템이 동시에 처리할 수 있는 트랜잭션 수가 줄어들게 됩니다. 이는 특히 트랜잭션이 많은 대규모 시스템에서 심각한 성능 문제로 이어질 수 있습니다.

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

1. 테스트 테이블 및 인덱스 생성

모든 테스트에서 사용할 테이블과 인덱스를 먼저 생성합니다.

import mysql from 'mysql2/promise';

const createTestTable = async () => {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db', // Docker 컨테이너에서 생성된 데이터베이스
  });

  await connection.execute(`DROP TABLE IF EXISTS test_table`);

  await connection.execute(`
    CREATE TABLE test_table (
      id INT AUTO_INCREMENT PRIMARY KEY,
      data VARCHAR(255),
      reference_id INT
    )
  `);

  // 인덱스 생성
  await connection.execute(`
    CREATE INDEX idx_reference_id ON test_table (reference_id)
  `);

  // 샘플 데이터 삽입
  await connection.execute(`
    INSERT INTO test_table (data, reference_id) VALUES
    ('첫 번째 행', 1),
    ('두 번째 행', 2),
    ('세 번째 행', 3)
  `);

  await connection.end();
};

createTestTable()
  .then(() => {
    console.log('테스트 테이블 및 인덱스가 성공적으로 생성되었습니다.');
  })
  .catch((err) => {
    console.error('테이블 생성 중 오류 발생:', err);
  });

2. READ UNCOMMITTED 격리 수준에서의 테스트

READ UNCOMMITTED 격리 수준에서는 커밋되지 않은 데이터를 읽을 수 있으며, 잠금이 거의 발생하지 않습니다. 이 테스트에서는 더러운 읽기가 어떻게 발생하는지를 확인합니다.

import mysql from 'mysql2/promise';

const testDirtyRead = async () => {
  const connection1 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  const connection2 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  // 격리 수준 설정
  await connection1.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED');
  await connection2.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED');

  // 트랜잭션 시작
  await connection1.beginTransaction();
  await connection2.beginTransaction();

  // 트랜잭션 1: 데이터 수정 (아직 커밋하지 않음)
  await connection1.execute(`UPDATE test_table SET data = '수정된 데이터' WHERE id = 1`);

  // 트랜잭션 2: 수정된 데이터 읽기
  const [rows] = await connection2.execute(`SELECT * FROM test_table WHERE id = 1`);
  console.log('트랜잭션 2에서 읽은 데이터:', rows);

  // 트랜잭션 1 롤백
  await connection1.rollback();

  // 트랜잭션 2 커밋
  await connection2.commit();

  await connection1.end();
  await connection2.end();
};

testDirtyRead()
  .then(() => {
    console.log('더러운 읽기 테스트 완료');
  })
  .catch((err) => {
    console.error('테스트 중 오류 발생:', err);
  });

결과 분석: 트랜잭션 2는 트랜잭션 1이 커밋하지 않은 데이터를 읽습니다. 그러나 트랜잭션 1이 롤백되면, 트랜잭션 2가 읽은 데이터는 실제로 존재하지 않는 "더러운 데이터"가 됩니다.

3. READ COMMITTED 격리 수준에서의 테스트

READ COMMITTED 격리 수준에서는 커밋된 데이터만 읽을 수 있습니다. 이 테스트에서는 반복 불가능한 읽기가 어떻게 발생하는지를 확인합니다.

import mysql from 'mysql2/promise';

const testNonRepeatableRead = async () => {
  const connection1 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  const connection2 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  // 격리 수준 설정
  await connection1.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED');
  await connection2.execute('SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED');

  // 트랜잭션 시작
  await connection1.beginTransaction();
  await connection2.beginTransaction();

  // 트랜잭션 1: 데이터 읽기
  const [initialRows] = await connection1.execute(`SELECT * FROM test_table WHERE id = 1`);
  console.log('트랜잭션 1에서 처음 읽은 데이터:', initialRows);

  // 트랜잭션 2: 데이터 수정 및 커밋
  await connection2.execute(`UPDATE test_table SET data = '트랜잭션 2에서 수정한 데이터' WHERE id = 1`);
  await connection2.commit();

  // 트랜잭션 1: 동일한 데이터 다시 읽기
  const [laterRows] = await connection1.execute(`SELECT * FROM test_table WHERE id = 1`);
  console.log('트랜잭션 1에서 나중에 읽은 데이터:', laterRows);

  // 트랜잭션 1 커밋
  await connection1.commit();

  await connection1.end();
  await connection2.end();
};

testNonRepeatableRead()
  .then(() => {
    console.log('반복 불가능한 읽기 테스트 완료');
  })
  .catch((err) => {
    console.error('테스트 중 오류 발생:', err);
  });

결과 분석: 트랜잭션 1은 동일한 쿼리를 두 번 실행하지만, 트랜잭션 2가 중간에 데이터를 수정하고 커밋했기 때문에 서로 다른 결과를 얻게 됩니다.

4. REPEATABLE READ 격리 수준에서의 테스트

REPEATABLE READ 격리 수준에서는 동일한 트랜잭션 내에서 동일한 쿼리에 대해 일관된 결과를 보장합니다. 이 테스트에서는 팬텀 읽기가 어떻게 발생하는지를 확인합니다.

import mysql from 'mysql2/promise';

const testPhantomRead = async () => {
  const connection1 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  const connection2 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  // 격리 수준 설정
  await connection1.execute('SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ');
  await connection2.execute('SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ');

  // 트랜잭션 시작
  await connection1.beginTransaction();
  await connection2.beginTransaction();

  // 트랜잭션 1: 특정 조건의 레코드 수 카운트
  const [initialRows] = await connection1.execute(`SELECT COUNT(*) as count FROM test_table WHERE reference_id > 1`);
  console.log('트랜잭션 1에서 처음 카운트한 레코드 수:', initialRows[0].count);

  // 트랜잭션 2: 새로운 레코드 삽입 및 커밋
  await connection2.execute(`INSERT INTO test_table (data, reference_id) VALUES ('새로운 데이터', 2)`);
  await connection2.commit();

  // 트랜잭션 1: 동일한 조건으로 다시 카운트
  const [laterRows] = await connection1.execute(`SELECT COUNT(*) as count FROM test_table WHERE reference_id > 1`);
  console.log('트랜잭션 1에서 나중에 카운트한 레코드 수:', laterRows[0].count);

  // 트랜잭션 1 커밋
  await connection1.commit();

  await connection1.end();
  await connection2.end();
};

testPhantomRead()
  .then(() => {
    console.log('팬텀 읽기 테스트 완료');
  })
  .catch((err) => {
    console.error('테스트 중 오류 발생:', err);
  });

결과 분석: 트랜잭션 1은 처음과 나중에 같은 조건으로 레코드 수를 카운트하지만, 트랜잭션 2가 새로운 레코드를 삽입하고 커밋했기 때문에 레코드 수가 증가합니다. 이는 팬텀 읽기의 예시입니다.

5. SERIALIZABLE 격리 수준에서의 테스트

SERIALIZABLE 격리 수준에서는 가장 높은 수준의 격리를 제공하며, 모든 트랜잭션이 직렬화된 것처럼 동작합니다. 이 테스트에서는 높은 격리 수준이 성능에 어떤 영향을 미치는지를 확인합니다.

import mysql from 'mysql2/promise';

const testSerializable = async () => {
  const connection1 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  const connection2 = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'test_db',
  });

  // 격리 수준 설정
  await connection1.execute('SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE');
  await connection2.execute('SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE');

  // 트랜잭션 시작
  await connection1.beginTransaction();
  await connection2.beginTransaction();

  // 트랜잭션 1: 데이터 읽기
  const [rows1] = await connection1.execute(`SELECT * FROM test_table WHERE id = 1`);
  console.log('트랜잭션 1에서 읽은 데이터:', rows1);

  // 트랜잭션 2: 동일한 데이터 수정 시도
  try {
    await connection2.execute(`UPDATE test_table SET data = '트랜잭션 2에서 수정한 데이터' WHERE id = 1`);
    await connection2.commit();
    console.log('트랜잭션 2에서 데이터 수정 및 커밋 성공');
  } catch (err) {
    console.error('트랜잭션 2에서 데이터 수정 중 오류 발생:', err);
    await connection2.rollback();
  }

  // 트랜잭션 1 커밋
  await connection1.commit();

  await connection1.end();
  await connection2.end();
};

testSerializable()
  .then(() => {
    console.log('SERIALIZABLE 격리 수준 테스트 완료');
  })
  .catch((err) => {
    console.error('테스트 중 오류 발생:', err);
  });

결과 분석: 트랜잭션 1이 데이터를 읽고 있는 동안, 트랜잭션 2는 동일한 데이터를 수정하려고 시도합니다. 그러나 SERIALIZABLE 격리 수준에서는 이러한 동시 접근이 제한되므로, 트랜잭션 2는 잠금으로 인해 대기하거나 오류를 발생시킬 수 있습니다. 이는 높은 격리 수준이 성능에 미치는 영향을 보여줍니다.

결론

MySQL에서의 잠금 메커니즘과 트랜잭션 격리 수준은 데이터의 무결성과 일관성을 유지하는 데 핵심적인 역할을 합니다. 각 격리 수준은 데이터의 일관성과 시스템의 성능 간의 균형을 다르게 취하고 있으며, 이에 따라 발생할 수 있는 문제가 존재합니다.

READ UNCOMMITTED 격리 수준에서는 "더러운 읽기" 문제가 발생할 수 있으며, 데이터의 일관성이 가장 낮습니다.
READ COMMITTED 격리 수준에서는 "반복 불가능한 읽기" 문제가 발생할 수 있지만, 더러운 읽기는 방지됩니다.
REPEATABLE READ 격리 수준에서는 "팬텀 읽기" 문제가 발생할 수 있지만, 일반적으로 데이터 일관성을 잘 유지할 수 있습니다.
SERIALIZABLE 격리 수준에서는 데이터 일관성이 가장 높게 보장되지만, 성능 저하가 심각할 수 있습니다.

트랜잭션 격리 수준과 잠금 메커니즘의 적절한 선택은 애플리케이션의 성능과 데이터 일관성을 유지하는 데 매우 중요합니다. 각 격리 수준에서 발생할 수 있는 문제와 이를 이해하기 위한 테스트 시나리오를 통해 MySQL이 트랜잭션을 관리하는 방식을 보다 명확히 이해할 수 있을 것입니다.

애플리케이션의 요구사항과 데이터베이스의 성능 요구 사항에 따라 적절한 격리 수준을 선택하는 것이 데이터베이스 시스템의 성능과 안정성을 최적화하는 핵심 요소임을 기억하세요. 각 격리 수준의 특징과 발생할 수 있는 문제를 잘 이해하고, 이를 바탕으로 최적의 데이터베이스 설정을 적용하는 것이 중요합니다.

이 포스팅이 MySQL에서의 트랜잭션 관리와 격리 수준에 대한 이해를 돕는 데 유용했기를 바랍니다.

'DataBase' 카테고리의 다른 글

Index Scan과 Index Seek (0)	2024.09.17
MongoDB와 MySQL에서의 트랜잭션과 동시성 관리: NestJS와 함께 살펴보는 실전 가이드 (0)	2024.09.16
SQL Server에서 Clustered Index와 Non-Clustered Index의 차이점 (0)	2024.08.12
데이터베이스 인덱스란 무엇인가요? (MySQL vs. SQL Server) (0)	2024.08.12
MySQL에서 B-Tree 인덱스란 무엇인가요? (0)	2024.08.12

Open-Closed Principle

MySQL에서의 잠금 메커니즘과 격리 수준: 공유 잠금(S LOCK)과 배타 잠금(EXCLUSIVE LOCK)의 동작 및 문제 발생 시나리오

잠금 메커니즘의 기본 개념

1. 공유 잠금 (S LOCK)

2. 배타 잠금 (EXCLUSIVE LOCK)

트랜잭션 격리 수준 (Transaction Isolation Levels)

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

2. READ COMMITTED (커밋된 상태 읽기)

3. REPEATABLE READ (반복 가능한 읽기)

4. SERIALIZABLE (직렬화 가능)

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

1. 테스트 테이블 및 인덱스 생성

잠금 메커니즘의 기본 개념

1. 공유 잠금 (S LOCK)

2. 배타 잠금 (EXCLUSIVE LOCK)

트랜잭션 격리 수준 (Transaction Isolation Levels)

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

2. READ COMMITTED (커밋된 상태 읽기)

3. REPEATABLE READ (반복 가능한 읽기)

4. SERIALIZABLE (직렬화 가능)

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

1. 테스트 테이블 및 인덱스 생성

2. READ UNCOMMITTED 격리 수준에서의 테스트

3. READ COMMITTED 격리 수준에서의 테스트

4. REPEATABLE READ 격리 수준에서의 테스트

5. SERIALIZABLE 격리 수준에서의 테스트

결론

'DataBase' 카테고리의 다른 글

티스토리툴바

MySQL에서의 잠금 메커니즘과 격리 수준: 공유 잠금(S LOCK)과 배타 잠금(EXCLUSIVE LOCK)의 동작 및 문제 발생 시나리오

잠금 메커니즘의 기본 개념

1. 공유 잠금 (S LOCK)

2. 배타 잠금 (EXCLUSIVE LOCK)

트랜잭션 격리 수준 (Transaction Isolation Levels)

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

2. READ COMMITTED (커밋된 상태 읽기)

3. REPEATABLE READ (반복 가능한 읽기)

4. SERIALIZABLE (직렬화 가능)

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

1. 테스트 테이블 및 인덱스 생성

잠금 메커니즘의 기본 개념

1. 공유 잠금 (S LOCK)

2. 배타 잠금 (EXCLUSIVE LOCK)

트랜잭션 격리 수준 (Transaction Isolation Levels)

1. READ UNCOMMITTED (읽지 않은 상태 읽기)

2. READ COMMITTED (커밋된 상태 읽기)

3. REPEATABLE READ (반복 가능한 읽기)

4. SERIALIZABLE (직렬화 가능)

각 격리 수준에서의 문제를 이해하기 위한 테스트 시나리오

1. 테스트 테이블 및 인덱스 생성

2. READ UNCOMMITTED 격리 수준에서의 테스트

3. READ COMMITTED 격리 수준에서의 테스트

4. REPEATABLE READ 격리 수준에서의 테스트

5. SERIALIZABLE 격리 수준에서의 테스트

결론

'DataBase' 카테고리의 다른 글

관련글

티스토리툴바