Bài giảng Hệ quản trị cơ sở dữ liệu - Chương 3: Điều khiển truy xuất đồng thời - Nguyễn Trường Sơn

	
  ghi	
  xong	
  X	
  cũng	
  không	
  làm	
  được	
  gì	
  vì:	
  
§  T	
  không	
  thể	
  đọc	
  X	
  vì	
  nếu	
  đọc	
  X	
  thì	
  sẽ	
  dẫn	
  đến	
  đọc	
  trễ	
  
§  Các	
  giao	
  tác	
  khác	
  sau	
  T	
  và	
  U	
  thì	
  muốn	
  đọc	
  giá	
  trị	
  X	
  được	
  ghi	
  bởi	
  U	
  
à   Giải	
  pháp:	
  Bỏ	
  qua	
  thao	
  thác	
  ghi	
  X	
  của	
  T	
  [Quy	
  tắc	
  ghi	
  Thomas]	
  
Nhãn thời gian riêng phần 
§  Vấn	
  đề	
  với	
  quy	
  tắc	
  ghi	
  Thomas	
  
70	
  
T	
  bắt	
  đầu	
   U	
  bắt	
  đầu	
  
T	
  ghi	
  X	
  
U	
  ghi	
  X	
  
T	
  kết	
  thúc	
   U	
  huỷ	
  
l  Trường	
  hợp	
  U	
  ghi	
  và	
  sau	
  đó	
  bị	
  huỷ	
  à 	
  giá	
  trị	
  được	
  ghi	
  bởi	
  U	
  đã	
  bị	
  mất	
  	
  
l  Do	
  T	
  đã	
  kết	
  thúc	
  à 	
  cần	
  khôi	
  phục	
  lại	
  giá	
  trị	
  X	
  từ	
  T	
  mà	
  lệnh	
  ghi	
  X	
  đã	
  bị	
  bỏ	
  qua	
  
à 	
  	
  Giải	
  pháp:	
  Khi	
  T	
  ghi	
  X,	
  nếu	
  giao	
  tác	
  U	
  đã	
  commit	
  thì	
  bỏ	
  qua	
  T,	
  hoặc	
  đợi	
  đến	
  thời	
  điểm	
  U	
  commit	
  hoặc	
  abort.	
  
Nhãn thời gian riêng phần 
§  Tóm	
  lại	
  khi	
  có	
  yêu	
  cầu	
  đọc	
  và	
  ghi	
  từ	
  giao	
  tác	
  T.	
  Bộ	
  lập	
  lịch	
  sẽ:	
  –  Đáp	
  ứng	
  yêu	
  cầu	
  –  Hủy	
  T	
  và	
  khởi	
  tạo	
  lại	
  T	
  với	
  1	
  timestamp	
  mới	
  
­ T	
  	
  rollback	
  –  Trì	
  hoãn	
  T,	
  sau	
  đó	
  mới	
  quyết	
  định	
  phải	
  hủy	
  T	
  hoặc	
  đáp	
  ứng	
  yêu	
  cầu	
  	
  
71	
  
Nhãn thời gian riêng phần 
§  Quy	
  tắc	
  :	
  –  Nếu	
  T	
  cần	
  đọc	
  X	
  
­ Nếu	
  WT(X)	
  ≤	
  TS(T)	
  thì	
  chờ	
  cho	
  X	
  trở	
  thành	
  Dữ	
  liệu	
  đã	
  Commit	
  rồi	
  cho	
  T	
  đọc	
  X	
  và	
  gán	
  RT(X)	
  =	
  MAX(RT(X),	
  TS(T))	
  
­ Ngược	
  lại	
  hủy	
  T	
  và	
  khởi	
  động	
  lại	
  T	
  cới	
  TS(T)	
  mới	
  (đọc	
  quá	
  trể)	
  	
  –  Nếu	
  T	
  cần	
  ghi	
  X	
  
­ Nếu	
  RT(X)	
  ≤	
  TS(T)	
  	
  –  Nếu	
  WT(X)	
  ≤	
  TS(T)	
  thì	
  cho	
  T	
  ghi	
  X	
  và	
  gán	
  WT(X)	
  =	
  TS(T)	
  –  Ngược	
  lại	
  thì	
  bỏ	
  qua	
  thao	
  tác	
  ghi	
  này	
  của	
  T	
  (không	
  hủy	
  T)	
  
­ Ngược	
  lại	
  hủy	
  T	
  và	
  khởi	
  động	
  lại	
  T	
  với	
  TS(T)	
  mới	
  (ghi	
  quá	
  trễ)	
  	
  
72	
  
Nhãn thời gian riêng phần (tt) 
§  Quy	
  tắc:	
  
73 
If	
  WT(X)	
  <=	
  TS(T)	
  	
  	
  	
   	
   	
  	
  Read(X);//cho	
  phép	
  đọc	
  X	
   	
  	
  RT(X):=	
  max(RT(X),TS(T));	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  Else	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
   	
  	
  Rollback{T};	
  	
  	
  	
  //hủy	
  T	
  và	
  khởi	
  tạo	
  lại	
  với	
  TS	
  mới	
  If	
  RT(X)	
  <=	
  TS(T)	
  If	
  WT(X)	
  <=	
  TS(T)	
  Write(X);//cho	
  phép	
  ghi	
  X	
  WT(X):=	
  TS(T);	
  	
  Else	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  Nếu	
  X	
  đã	
  COMMIT	
  à 	
  bỏ	
  qua,	
  ngược	
  lại	
  chờ	
  cho	
  đến	
  khi	
  giao	
  tác	
  thực	
  hiện	
  ghi	
  trên	
  X	
  commit	
  hoặc	
  abort	
   	
  	
  	
  Else 	
   	
   	
   	
  	
  	
   	
  	
  Rollback{T};	
  	
  //hủy	
  T	
  và	
  khởi	
  tạo	
  lại	
  với	
  TS	
  mới	
  
Read(T,	
  X)	
  
Write(T,	
  X)	
  
Ví dụ 
74 
1	
  
2	
  
3	
  
4	
  
5	
  
T1	
  
Read(A)	
  
T2	
  
TS(T2)=200	
  
A	
  
RT(A)=0	
  
B	
  
RT(B)=0	
  
Read(B)	
  
Write(A)	
  
Write(B)	
  
Read(C)	
  
TS(T1)=100	
   WT(A)=0	
   WT(B)=0	
  
RT(A)=100	
  
WT(A)=0	
  
RT(B)=200	
  
WT(B)=0	
  
RT(A)=100	
  
WT(A)=100	
  
RT(B)=200	
  
WT(B)=200	
  
C	
  
RT(C)=0	
  
WT(C)=0	
  
RT(C)=200	
  
WT(C)=0	
  
Read(C)	
   RT(C)=200	
  
WT(C)=0	
  
Write(C)	
  
WT(A)	
  <	
  TS(T1)	
  
T1	
  đọc	
  được	
  A	
  
WT(B)	
  <	
  TS(T2)	
  
T2	
  đọc	
  được	
  B	
  
RT(A)	
  <	
  TS(T1)	
   T1	
  ghi	
  lên	
  
A	
  được	
  WT(A)	
  =	
  TS(T1)	
  
RT(B)	
  <	
  TS(T2)	
   T2	
  ghi	
  lên	
  
B	
  được	
  WT(B)	
  =	
  TS(T2)	
  
WT(B)	
  <	
  TS(T2)	
  
T2	
  đọc	
  được	
  C	
  
WT(C)	
  <	
  TS(T1)	
  
T1	
  đọc	
  được	
  C	
  
6	
  
7	
   RT(C)	
  >	
  TS(T1)	
  
T1	
  không	
  ghi	
  lên	
  C	
  được	
  
Abort	
  
Ví dụ (tt) 
75 
T1	
  
Read(B)	
  
T2	
  
TS=150	
  
A	
  
RT=0	
  
B	
  
RT=0	
  
Read(A)	
  
Write(B)	
  
Write(A)	
  
Write(A)	
  
TS=200	
   WT=0	
   WT=0	
  
RT=200	
  
WT=0	
  
RT=150	
  
WT=0	
  
RT=175	
  
WT=0	
  
RT=200	
  
WT=200	
  
C	
  
RT=0	
  
WT=0	
  
RT=150	
  
WT=200	
  
Write(C)	
  
Rollback	
  
T3	
  
TS=175	
  
Read(C)	
  
Giá	
  trị	
  của	
  A	
  đã	
  sao	
  lưu	
  bởi	
  T1	
  →	
  T3	
  không	
  bị	
  
rollback	
  và	
  không	
  cần	
  ghi	
  A	
  
Bài tập 
§  Given	
  the	
  following	
  sequence	
  of	
  events:	
  	
  –  st1;	
  st2;	
  r1(A);	
  r2(B);	
  w2(A);	
  w1(B)	
  –  st1;	
  st2;	
  st3;	
  r1(A);	
  r3(B);	
  w1(C);	
  r2(B);	
  r2(C);	
  w3(B);	
  w2(A)	
  	
  
§  Task:	
  Tell	
  what	
  happens	
  as	
  each	
  event	
  occurs	
  for	
  a	
  timestamp	
  based	
  scheduler.	
  	
  
76	
  
Ví dụ (tt) 
77 
T1	
  
Read(A)	
  
T2	
  
TS=200	
  
A	
  
RT=0	
  
Read(A)	
  
Write(A)	
  
Write(A)	
  
Read(A)	
  
TS=150	
   WT=0	
  
RT=150	
  
WT=0	
  
RT=200	
  
WT=200	
  
T3	
  
TS=175	
  
Rollback	
  
T4	
  
TS=255	
  
Read(A)	
  
RT=150	
  
WT=150	
  
RT=200	
  
WT=0	
  
RT=255	
  
WT=200	
  
T3	
  bị	
  hủy	
  vì	
  nó	
  định	
  đọc	
  giá	
  trị	
  A	
  ghi	
  bởi	
  T2	
  (mà	
  T2	
  lại	
  có	
  nhãn	
  thời	
  gian	
  lớn	
  hơn	
  nó).	
  Giả	
  sử	
  T3	
  đọc	
  giá	
  trị	
  A	
  ghi	
  bởi	
  T1	
  thì	
  T3	
  sẽ	
  không	
  bị	
  hủy	
  
Ý	
  tưởng	
  lưu	
  giữ	
  nhiều	
  	
  phiên	
  bản	
  của	
  A	
  
Nội dung trình bày 
§  Các	
  vấn	
  đề	
  của	
  truy	
  xuất	
  đồng	
  thời	
  	
  
§  Các	
  kỹ	
  thuật	
  điều	
  khiển	
  đồng	
  thời:	
  	
  –  Kỹ	
  thuật	
  khoá	
  
­ Khoá	
  đơn	
  giản	
  
­ Khoá	
  đọc	
  ghi	
  
­ Khoá	
  đa	
  hạt	
  –  Kỹ	
  thuật	
  nhãn	
  thời	
  gian	
  	
  
­ Nhãn	
  thời	
  gian	
  toàn	
  phần	
  
­ Nhãn	
  thời	
  gian	
  riêng	
  phần	
  
­ Nhãn	
  thời	
  gian	
  nhiều	
  phiên	
  bản	
  –  Kỹ	
  thuật	
  xác	
  nhận	
  hợp	
  lệ	
  	
  
§  Vấn	
  đề	
  khoá	
  chết	
  
§  Các	
  vấn	
  đề	
  khác	
   78	
  
Nhãn thời gian nhiều phiên bản 
§  Ý	
  tưởng	
  –  Cho	
  phép	
  thao	
  tác	
  read(A)	
  của	
  T3	
  thực	
  hiện	
  
§  Bên	
  cạnh	
  việc	
  lưu	
  trữ	
  giá	
  trị	
  hiện	
  hành	
  của	
  A,	
  ta	
  giữ	
  lại	
  các	
  giá	
  trị	
  được	
  sao	
  lưu	
  trước	
  kia	
  của	
  A	
  (phiên	
  bản	
  của	
  A)	
  
§  Giao	
  tác	
  T	
  sẽ	
  đọc	
  được	
  giá	
  trị	
  của	
  A	
  ở	
  1	
  phiên	
  bản	
  thích	
  hợp	
  nào	
  đó	
  
79 
Nhãn thời gian nhiều phiên bản (tt) 
§  Mỗi	
  phiên	
  bản	
  của	
  1	
  đơn	
  vị	
  dữ	
  liệu	
  X	
  có	
  –  RT(X)	
  	
  
­ Ghi	
  nhận	
  lại	
  giao	
  tác	
  sau	
  cùng	
  đọc	
  X	
  thành	
  công	
  	
  –  WT(X)	
  	
  
­ Ghi	
  nhận	
  lại	
  giao	
  tác	
  sau	
  cùng	
  ghi	
  X	
  thành	
  công	
  
§  Khi	
  giao	
  tác	
  T	
  phát	
  ra	
  yêu	
  cầu	
  thao	
  tác	
  lên	
  X	
  –  Tìm	
  1	
  phiên	
  bản	
  thích	
  hợp	
  của	
  X	
  –  Đảm	
  bảo	
  tính	
  khả	
  tuần	
  tự	
  
§  Một	
  phiên	
  bản	
  mới	
  của	
  X	
  sẽ	
  được	
  tạo	
  khi	
  hành	
  động	
  ghi	
  X	
  thành	
  công	
  
80 
Nhãn thời gian nhiều phiên bản (tt) 
§  Quy	
  tắc:	
  
81 
i=“số	
  thứ	
  tự	
  phiên	
  bản	
  sau	
  cùng	
  nhất	
  của	
  X”	
  While	
  WT(Xi)	
  >	
  TS(T)	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  i:=i-­‐1;//lùi	
  lại	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  Read(Xi);	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  RT(Xi):=	
  max(RT(Xi),	
  TS(T)); 	
   	
   	
  	
  i=“số	
  thứ	
  tự	
  phiên	
  bản	
  sau	
  cùng	
  nhất	
  của	
  X”	
  	
  While	
  WT(Xi)	
  >	
  TS(T)	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
   	
  	
  i:=i-­‐1;//lùi	
  lại	
  	
  	
  If	
  RT(Xi)	
  >	
  TS(T)	
  	
  Rollback	
  T//Hủy	
  và	
  khởi	
  tạo	
  TS	
  mới 	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  	
  Else	
  	
  Tạo	
  phiên	
  bản	
  Xi+1;	
  Write(Xi+1);	
  RT(Xi+1)	
  =	
  0;//chưa	
  có	
  ai	
  đọc	
  	
  	
  WT(Xi+1)	
  =	
  TS(T);	
  
Read(T,	
  X)	
  
Write(T,	
  X)	
  
Ví dụ 
82 
RT=150 
WT=0 
RT=0 
WT=200 
T1 
Read(A) 
T2 
TS=200 
A0 
RT=0 
Read(A) 
Write(A) 
Write(A) 
Read(A) 
TS=150 WT=0 
T3 
TS=175 
T4 
TS=255 
Read(A) 
RT=0 
WT=150 
RT=200 
WT=150 
RT=200 
WT=150 
A1 A2 
RT=255 
WT=200 
Ví dụ (tt) 
83 
T1 
TS=100 
T2 
TS=200 
Read(A) 
Write(A) 
Write(B) 
Read(B) 
Write(A) 
A0 
RT=0 
WT=0 
RT=100 
WT=0 
A1 
RT=0 
WT=200 
B0
RT=0 
WT=0 
B1 
RT=0 
WT=200 
RT=100 
WT=0 
RT=0 
WT=100 
A2 
RT=0 
WT=200 
Nhãn thời gian nhiều phiên bản (tt) 
§  Nhận	
  xét	
  –  Thao	
  tác	
  đọc	
  
­ Giao	
  tác	
  T	
  chỉ	
  đọc	
  giá	
  trị	
  của	
  phiên	
  bản	
  do	
  T	
  hay	
  những	
  giao	
  tác	
  trước	
  T	
  cập	
  nhật	
  
­ T	
  không	
  đọc	
  giá	
  trị	
  của	
  các	
  phiên	
  bản	
  do	
  các	
  giao	
  tác	
  sau	
  T	
  cập	
  nhật	
  
→	
  Thao	
  tác	
  đọc	
  không	
  bị	
  rollback	
  –  Thao	
  tác	
  ghi	
  	
  
­ Thực	
  hiện	
  được	
  thì	
  chèn	
  thêm	
  phiên	
  bản	
  mới	
  
­ Không	
  thực	
  hiện	
  được	
  thì	
  rollback	
  –  Tốn	
  nhiều	
  chi	
  phí	
  tìm	
  kiếm,	
  tốn	
  bộ	
  nhớ	
  –  Nên	
  giải	
  phóng	
  các	
  phiên	
  bản	
  quá	
  cũ	
  không	
  còn	
  được	
  các	
  giao	
  tác	
  sử	
  dụng	
  
84 
Tài liệu tham khảo 
§  [5]	
  Database	
  systems:	
  the	
  complete	
  book,	
  Hector	
  Garcia-­‐Molina,	
  Jeffrey	
  D.	
  Ullman,	
  Jennifer	
  Widom,	
  Pearson	
  Prentice	
  Hall,	
  2009	
  –  Chapter	
  18.	
  Concurency	
  Control	
  	
  	
  
85	
  
LOGO 
86	
  
Q	
  &	
  A	
  	
  
Tóm tắt CHƯƠNG 3 
§  Các	
  kỹ	
  thuật	
  điều	
  khiển	
  truy	
  xuất	
  đồng	
  thời	
  –  Kỹ	
  thuật	
  khoá	
  
­ Kỹ	
  thuật	
  khoá	
  đơn	
  giản	
  
­ Kỹ	
  thuật	
  khoá	
  đọc	
  ghi	
  
­ Nghi	
  thức	
  2	
  giai	
  đoạn	
  
­ Khoá	
  cập	
  nhật	
  
­ Các	
  tình	
  huống	
  xảy	
  ra	
  deadlock,	
  các	
  loại	
  deadlock	
  
­ Khoá	
  đa	
  hạt	
  	
  –  Kỹ	
  thuật	
  nhãn	
  thời	
  gian	
  
­ Kỹ	
  thuật	
  nhãn	
  thời	
  gian	
  toàn	
  phần	
  
­ Kỹ	
  thuật	
  nhãn	
  thời	
  gian	
  riêng	
  phần	
  
­ Kỹ	
  thuật	
  nhãn	
  thời	
  gian	
  nhiều	
  phiên	
  bản	
  	
  	
  
87	
  
Timestamp vs. Locking 
§  Schedule	
  allowed	
  by	
  locks	
  but	
  not	
  timestamps	
  	
  
§  Schedule	
  allowed	
  by	
  timestamps	
  but	
  not	
  by	
  locks:	
  	
  
88	
  
Cascading Rollbacks 
§  One	
  transaction	
  aborting	
  can	
  cause	
  other	
  transactions	
  to	
  abort.	
  	
  
§  T22	
  aborts	
  ⇒	
  we	
  have	
  to	
  rollback	
  T23	
  and	
  T24.	
  	
  
§  How	
  to	
  eliminate	
  these	
  cascading	
  rollbacks?	
  	
  –  Don't	
  let	
  transactions	
  read	
  “dirty”	
  uncommitted	
  data.	
  
89	
  
Strict Timestamp Based Concurrency 
Control 
§  How	
  to	
  avoid	
  cascading	
  rollbacks?	
  	
  –  Transactions	
  should	
  read	
  only	
  committed	
  values.	
  	
  
§  Strict	
  timestamp	
  concurrency	
  control	
  protocol	
  	
  
90	
  
SQL isolation levels 
§  A	
  transactions	
  in	
  SQL	
  may	
  be	
  chosen	
  to	
  have	
  one	
  of	
  four	
  
isolation	
  levels:	
  	
  
§  !  READ	
  UNCOMMITTED:	
  ”No	
  locks	
  are	
  obtained.”	
  	
  
§  !  READ	
  COMMITTED:	
  ”Read	
  locks	
  are	
  immediately	
  released	
  –	
  read	
  values	
  may	
  change	
  during	
  the	
  transaction.”	
  	
  
§  !  REPEATABLE	
  READ:	
  ”2PL	
  but	
  no	
  lock	
  when	
  adding	
  new	
  tuples.”	
  	
  
§  ! SERIALIZABLE:	
  ”2PL	
  with	
  lock	
  when	
  adding	
  new	
  tuples.”	
  	
  
91	
  
Disadvantages of locking 
•  Lock	
  management	
  overhead.	
  •  Deadlock	
  detection/resolution.	
  •  Concurrency	
  is	
  signi£icantly	
  lowered,	
  when	
  congested	
  nodes	
  are	
  locked.	
  •  To	
  allow	
  a	
  transaction	
  to	
  abort	
  itself	
  when	
  mistakes	
  occur,	
  locks	
  can’t	
  be	
  released	
  until	
  the	
  end	
  of	
  transaction,	
  thus	
  currency	
  is	
  signi£icantly	
  lowered	
  	
  •  (Most	
  Important)	
  Con£licts	
  are	
  rare.	
  (We	
  might	
  get	
  better	
  performance	
  by	
  not	
  locking,	
  and	
  instead	
  checking	
  for	
  con£licts	
  at	
  commit	
  time.)	
  
92	
  
Optimism vs pessimism 
§  ! Pessimistic	
  concurrency	
  is	
  best	
  in	
  high-­‐	
  con£lict	
  situations:	
  	
  
–  ! Smallest	
  number	
  of	
  aborts.	
  	
  
–  ! No	
  wasted	
  processing.	
  	
  
§  ! Optimistic	
  concurrency	
  control	
  is	
  best	
  if	
  con£licts	
  are	
  rare,	
  e.g.,	
  if	
  there	
  are	
  many	
  read-­‐only	
  transactions.	
  	
  
–  ! Highest	
  level	
  of	
  concurrency.	
  	
  
–  !  Hybrid	
  solutions	
  often	
  used	
  in	
  practice.	
  	
  
93	
  
Two-Phase Locking (2PL) . . . 
§  Properties	
  of	
  the	
  2PL	
  protocol	
  	
  –  Generates	
  conƒlict-­‐serializable	
  schedules	
  	
  	
  –  But	
  schedules	
  may	
  cause	
  cascading	
  aborts	
  	
  ∗	
  If	
  a	
  transaction	
  aborts	
  after	
  it	
  releases	
  a	
  lock,	
  it	
  may	
  cause	
  other	
  transactions	
  that	
  have	
  accessed	
  the	
  unlocked	
  data	
  item	
  to	
  abort	
  as	
  well	
  	
  
§  Strict	
  2PL	
  locking	
  protocol	
  –  Holds	
  the	
  locks	
  till	
  the	
  end	
  of	
  the	
  transaction	
  	
  	
  	
  –  Cascading	
  aborts	
  are	
  avoided	
  	
  	
  
94	
  
Timestamp-based approach 
§  Assumed	
  Serial	
  Schedule	
  in	
  Timestamp-­‐based	
  approach:	
  –  Con£lict	
  serializable	
  schedule	
  that	
  is	
  equivalent	
  to	
  a	
  serial	
  schedule	
  in	
  which	
  the	
  timestamp	
  order	
  of	
  transactions	
  is	
  the	
  order	
  to	
  execute	
  them	
  	
  
95	
  
Timestamp-based approach 
§  Scheduler’s	
  response	
  to	
  a	
  T’s	
  request	
  	
  –  Grant	
  the	
  request	
  	
  –  Abort	
  and	
  restart	
  (roll	
  back)	
  T	
  with	
  a	
  new	
  timestamp	
  	
  –  Delay	
  T	
  and	
  later	
  decide	
  whether	
  to	
  abort	
  T	
  or	
  to	
  grant	
  the	
  request	
  	
  
96	
  
THUẬT NGỮ 
§  Bộ	
  lập	
  lịch	
  
§  Bộ	
  phận	
  quản	
  lý	
  giao	
  tác	
  
§  Bảng	
  khoá	
  
§  Bộ	
  phận	
  quản	
  lý	
  đồng	
  thời	
  
97