2 Thiết kế chương trình

39



ở New Hampshire, New Jersey và tiểu bang Massachusetts. Đƣợc thành lập vào

năm 1994, IndexData chuyên về giải pháp quản lý và khai phá thông tin phân

tán.

IndexData là một thành viên trong nhóm triển khai Z39.50 ZIG và ZING. YAZ

là một bộ công cụ lập trình hỗ trợ phát triển Z39.50/SRW/SRU phía khách và

chủ do IndexData phát triển. Z39.50-2003 (phiên bản 3) cũng nhƣ SRW / SRU

phiên bản 1.1 đƣợc hỗ trợ trong cả hai vai trò khách/chủ.

YAZ đã đƣợc rộng rãi công nhận là bộ công cụ hàng đầu để xây dựng các hệ

thống khách và chủ hỗ trợ Z39.50 kể từ bản phát hành đầu tiên vào năm 1995.

Trong suốt một thập kỷ của dịch vụ đang hoạt động, bộ công cụ YAZ trở nên

thiện chiến trong mọi loại hình ứng dụng, và lớn lên trong sự hỗ trợ cho ngay cả

những khía cạnh bí truyền của các giao thức Z39.50 và SRW.

Nhiều ứng dụng Z39.50 khách và chủ sử dụng trên toàn thế giới dựa trên YAZ

hơn bất kỳ bộ công cụ khác.

Thống kê từ trang Z39.50 IndexData của Target Directory biên soạn trong mùa

thu năm 2004 cho thấy ít nhất 35% máy chủ Z39.50 của toàn thế giới đƣợc xây

dựng với YAZ. Ƣớc tính rằng con số thực có lẽ là gần hơn với 50%, nhƣng một

tỷ lệ phần trăm chính xác không đƣợc biết. Sử dụng số liệu thống kê thu thập

đƣợc vào giữa năm 2004 từ cổng Z39.50 của Thƣ viện Quốc Hội Mỹ cho biết

rằng tối thiểu là 65%, và có thể hơn nhiều, hệ thống khách truy cập vào LC dựa

trên bộ công cụ YAZ.

Bộ công cụ YAZ là mã nguồn mở, miễn phí, và vì tất cả lý do trên, tôi chọn

YAZ để phát triển giải pháp của mình.

YAZ là một bộ thƣ viện lập trình cho C/C++ nên tôi đã phát triển một thƣ viện

chƣơng trình CSZOOMC.dll (Csharp Z39.50 Object Model Component) nhƣ là

một vỏ bọc các API của YAZ để triệu gọi và sử dụng dễ dàng trong các ứng

dụng phát triển bằng công nghệ Microsoft.NET.

3.2.2 Xây dựng ứng dụng đa luồng với Microsoft.Net

Đa luồng là một công cụ mạnh mẽ để tạo các ứng dụng hiệu suất cao, đặc biệt là

các ứng dụng có yêu cầu tƣơng tác với ngƣời dùng hoặc làm việc với các dịch

vụ và tài nguyên phân tán. Microsoft. NET đã phá vỡ những rào cản đó từng tồn

tại trong việc tạo ra các ứng dụng đa luồng.

3.2.2.1 Khái niệm về luồng(thread)

Để hiểu đƣợc đa luồng đầu tiên chúng ta phải hiểu các luồng. Mỗi ứng dụng /

chƣơng trình đang chạy trên một hệ thống là một tiến trình. Tiến trình cho mỗi

39



40



chƣơng trình bao gồm một hoặc nhiều luồng mà bộ xử lý cần một thời gian nhất

định để thực hiện. Mỗi luồng có chứa tất cả các thông tin ngữ cảnh đƣợc yêu cầu

bởi hệ thống để thực hiện các lệnh của chƣơng trình.

Hệ điều hành có trách nhiệm lập kế hoạch và thực hiện các luồng. Hãy nhớ

những ngày của Windows 3.x? Một tiến trình luồng duy nhất có thể, và thƣờng

làm, độc quyền tất cả các thời gian xử lý. Hệ thống sẽ chỉ ngồi và chờ đợi cho

luồng đó hoàn thành trƣớc khi thực hiện bất kỳ tiến trình khác.

Các hệ điều hành mới hơn, chẳng hạn nhƣ Windows 2000, hỗ trợ đa nhiệm chặn

trƣớc nó phân bổ mỗi luồng một lát thời gian. Khi thời lát gian của luồng hiện

đang thực hiện đã trôi qua, luồng bị đình chỉ bởi hệ điều hành, bối cảnh của

luồng đƣợc lƣu, bối cảnh của luồng khác đƣợc tải, và luồng khác thì tiếp tục

thực hiện theo trạng thái trƣớc đó. Điều này đem đến sự xuất hiện nhiều luồng

đƣợc thực hiện đồng thời và ngăn chặn hệ thống trở thành không phản hồi từ

một luồng đơn (kết thúc nhiệm vụ bất cứ ai?). Trên các hệ thống có hơn một bộ

xử lý, các luồng đƣợc phân bổ qua tất cả các bộ xử lý nhƣ vậy thực sự có nhiều

luồng đang đƣợc thi hành tại cùng một thời điểm.

3.2.2.2 Căn bản về mô hình luồng

Single Thread - Đơn luồng có nghĩa là chỉ có một luồng trong một tiến trình và

nó đang làm tất cả các công việc cho tiến trình này. Tiến trình phải chờ đợi thực

thi hiện tại của luồng hoàn thành trƣớc khi nó có thể thực hiện một hành động

khác.

Kết quả đơn luồng ở thời gian nhàn rỗi của hệ thống và sự thất vọng của ngƣời

dùng. Ví dụ, giả sử chúng ta đang lƣu một tệp tin vào một mạng từ xa bằng cách

sử dụng một ứng dụng đơn luồng. Vì chỉ có một luồng duy nhất trong ứng dụng,

ứng dụng sẽ không thể làm bất cứ điều gì khác trong khi tệp tin đang đƣợc lƣu

giữ vào vị trí từ xa. Vì vậy ngƣời dùng chờ đợi và bắt đầu tự hỏi, liệu ứng dụng

bao giờ sẽ tiếp tục.

Apartment Threading (Single Threaded Apartment – căn hộ đơn luồng)

Apartment threaded - Căn hộ luồng có nghĩa là có nhiều luồng trong ứng dụng.

Trong căn hộ luồng đơn (single thread apartment - STA) mỗi luồng bị cô lập

trong một căn hộ riêng biệt bên dƣới tiến trình. Tiến trình qui định khi nào và

trong bao lâu luồng trong mỗi căn hộ có thể thi hành. Mọi yêu cầu đƣợc xếp

hàng thông qua hàng đợi thông điệp của Windows, nhƣ vậy chỉ có một căn hộ

luồng duy nhất đƣợc truy cập tại một thời điểm và do đó chỉ có một luồng đơn

sẽ đƣợc thực hiện tại một thời điểm. STA là mô hình luồng mà hầu hết các nhà

phát triển Visual Basic quen thuộc vì đây là mô hình luồng có sẵn cho các ứng

dụng VB trƣớc khi có VB.NET. Bạn có thể nghĩ nó nhƣ một hàng các căn hộ

một phòng mà có thể truy cập tới một tại một thời điểm thông qua một hành

40



41



lang duy nhất. Ƣu điểm của nó so với đơn luồng là nhiều lệnh có thể đƣợc ban

hành cùng một lúc thay vì chỉ một lệnh duy nhất, nhƣng các lệnh vẫn tuần tự

thực hiện.

Free Threading (Multi Threaded Apartment – căn hộ đa luồng)

Các ứng dụng luồng tự do giới hạn trong các ngôn ngữ nhƣ C++ cho tới khi

Microsoft.NET ra đời. Mô hình Luồng tự do/Multi Threaded Apartment (MTA)

có duy nhất một căn hộ đơn đƣợc tạo gia bên dƣới tiến trình chứ không phải

nhiều căn hộ. Một căn hộ đơn chứa đựng nhiều luồng hơn là chỉ một luồng.

Không cần hàng đợi thông điệp bởi vì tất cả các luồng là một phân của cùng một

căn hộ và có thể chia sẻ dữ liệu mà không cần proxy. Bạn có thể nghĩ nó nhƣ là

một công trình với nhiều phòng mà đều có thể vào đƣợc một khi bạn đã ở bên

trong. Các ứng dụng này thƣờng thực hiện nhanh hơn so với đơn luồng và STA

vì có ít hệ thống hơn và có thể đƣợc tối ƣu hóa để loại bỏ thời gian nhàn rỗi của

hệ thống.

Các loại ứng dụng này là phức tạp hơn khi lập trình. Ngƣời phát triển phải cung

cấp sự đồng bộ hóa giữa các luồng nhƣ một phần của mã lệnh để chắc chắn các

luồng không đồng thời truy cập tới cùng các nguồn tài nguyên. Một điều kiện

đƣợc biết đến nhƣ trƣờng hợp tranh đua có thể xuất hiện khi luồng truy cập tới

tài nguyên chia sẻ và thay đổi tài nguyên tới một trạng thái không hợp lệ và khi

luồng khác truy cập tới tài nguyên và sử dụng nó trong điều kiện không hợp lệ

trƣớc khi một luồng khác trả tài nguyên về trạng thái hợp lệ. Vì vậy việc cần

thiết đặt một khóa vào tài nguyên để ngăn chặn các luồng khác truy cập cho tới

khi khóa đƣợc bỏ đi. Tuy nhiên, điều này có thể dẫn đến tình huống bế tắc nơi

hai luồng cạnh tranh về tài nguyên mà không cái nào xử lý đƣợc. Ví dụ, luồng

#1 có một tài nguyên bị khóa và đang chờ tài nguyên khác đang khóa bởi luồng

#2. Luồng #2 lại xuất hiện tình trạng đang chờ đợi tài nguyên bị khóa bởi luồng

#1. Nhƣ vậy, cả hai luồng đều đang chờ đợi lẫn nhau và không luồng nào sẽ

đƣợc cho phép xử lý. Chỉ có một con đƣờng để tránh tình trạng trên là thông qua

thiết kế và kiểm thử tốt.

3.2.3 Cấu trúc và Giải thuật

Ứng dụng đƣợc xây dựng với 3 thành phần chính:

- UI – User Interface (giao diện ngƣời dùng) là các trang web hiển thị giao

diện tìm kiếm, kết quả và các thông tin khác. Từ giao diện này ngƣời

dùng chọn lựa danh sách cơ sở dữ liệu cần tìm, đƣa vào câu truy vấn và

gửi tới ZetMonitor – Bộ quản lý các luồng Z39.50 client. UI cũng nhận

kết quả trả về và các thông tin khác để hiển thị cho ngƣời dùng.

- ZetMonitor – Bộ quản lý luồng Z39.50 client. ZetMonitor nhận câu lệnh

truy vấn và danh sách cơ sở dữ liệu đích từ tầng UI. Khởi tạo các luồng

41



42



Z39.50 client, mỗi luồng làm việc với 1 cơ sở dữ liệu. Số lƣợng các luồng

đƣợc qui định bằng kích thƣớc mảng các luồng Z39.50 client theo cấu

hình đảm bảo hệ thống hoạt động hiệu quả. Mỗi luồng khi gặp lỗi hoặc

hoàn thành nhiệm vụ sẽ đƣợc loại bỏ khỏi mảng các luồng và một luồng

khác làm việc với cơ sở dữ liệu mới sẽ đƣợc đƣa vào cho đến khi hết

danh sách cơ sở dữ liệu đích, hoặc lệnh hủy ZetMonitor đƣợc gọi.

ZetMonitor quản lý một mảng kết quả trả về từ phía các luồng Z39.50

client và cung cấp theo yêu cầu của tầng UI. Mảng kết quả trả về không

có độ dài cố định, nó sẽ đƣợc mở rộng khi ngƣời dùng duyệt tới gần cuối

mảng.

- ZetThread – Luồng Z39.50 client là một Z39.50 client, khi đƣợc khởi tạo

nhận câu truy vấn và thông tin cơ sở dữ liệu đích từ ZetMonitor. Khi

chạy sẽ kết nối và gửi yêu cầu đến Z39.50 server. Nếu gặp lỗi sẽ gửi tình

trạng đến ZetMonitor để ZetMonitor loại bỏ ZetThread này khỏi mảng và

thêm ZetThread khác vào nếu có. ZetThread nhận thông tin số biểu ghi

trả về từ Z39.50 server, thực hiện tải về bản ghi lần lƣợt. Với mỗi bản ghi

tải về xong ZetThread cố gắng gửi tới ZetMonitor, nếu đƣợc ZetMonitor

chấp nhận nó sẽ lấy bản ghi tiếp và gửi cho ZetMonitor, nếu không, nó

nằm nghỉ một lát và gửi lại. Cứ nhƣ vậy cho đến khi hết kết quả hoặc nó

bị hủy đi.

Việc xây dựng một lƣợc đồ cho loại ứng dụng đa luồng gặp nhiều khó khăn do

tính chất phức tạp của các trạng thái. Do vậy tôi cố gắng đƣa ra mô tả về cấu

trúc và hoạt động của các thành phần chƣơng trình nhƣ trên.



42



43



3.2.4 Sơ đồ lớp và mã nguồn chính

3.2.4.1 Class Diagram



Hình 4: Mô hình lớp



3.2.4.2 Lớp ThreadHelper

Lớp ThreadHelper giúp khởi tạo và quản lý luồng đƣợc kế thừa trong lớp

ZetThread

using System;

using System.Threading;

namespace ZetPortal

{

public class ThreadHelper

{

protected Thread threadField;

public ThreadHelper()

{

threadField = new Thread(new ThreadStart(Run));

}

public ThreadHelper(String name)

{

threadField = new Thread(new ThreadStart(Run));

threadField.Name = name;



43



44

}

public virtual void Run()

{

}

public virtual void Start()

{

threadField.Start();

}

public virtual void Interrupt()

{

threadField.Interrupt();

}

public virtual void Abort()

{

threadField.Abort();

}

public virtual void Join()

{

threadField.Join();

}

public virtual void Join(int miliseconds)

{

threadField.Join(miliseconds);

}

public bool IsAlive

{

get { return threadField.IsAlive; }

}

public bool IsBackground

{

get { return threadField.IsBackground; }

set { if (threadField.IsAlive) threadField.IsBackground =

value; }

}

}

}



3.2.4.3 Lớp ZetThread

Kế thừa từ lớp ThreadHelper để khởi tạo một Z39.50 client hoạt động nhƣ một

luồng -Thread.

using System;

using CSZOOMC;

using System.Threading;

using MarcXmlParser;

namespace ZetPortal

{

public class ZetThread : ThreadHelper

{

private ZoomConnection _zc;

private ZoomQuery _zqry;

private ZoomResultSet _zrs;

public event Thread_Done Done;

public event Thread_Send_Record Send_Record;

public event Thread_Send_FoundCount Send_Size;

public event Thread_Status_Changed Status_Changed;

private int _iReceivedCount = 0;

private int _iFoundCount = 0;

private ZDb _DbInfo = new ZDb();

private string _strQuery;



44



45

private int _index=0;

public ZetThread(int index,String sName,String sDbInfo, String

strQuery): base(sName)

{

//string Name, string Host,int Port,string Database,string

Charset

_index = index; // indentifier of the thread in thread array of

Monitor

_DbInfo.load_Xml(sDbInfo);

_strQuery= strQuery;

}

~ZetThread()

{

try

{

if (threadField.IsAlive)

{

threadField.Abort();

threadField.Join();

}

_zrs = null;

_zc = null;

}

catch(Exception ex)

{

//do nothing

String errorString=ex.Message;

}

finally

{

//do nothing

}

}

public override void Run()

{

try

{

createConnection();

_zrs = _zc.Search(_zqry);

int count = _zrs.GetSize();

if ((count > 0) && (_iFoundCount == 0))

{

Send_Size(count);

_iFoundCount = count;

}

int start = _iReceivedCount;

Status_Changed(_index, "Running", _iReceivedCount,

_iFoundCount);

for (int i = start; i < count; i++)

{

ZoomRecord zr = _zrs.GetRecord(i);

String xmlRecord = string.Empty;

CRecord myRec = new CRecord();

if (_DbInfo.Charset.ToLower().Trim() == "a")

{

xmlRecord = zr.GetXMLRecord(_DbInfo.Charset);

}

else //auto detect charset

{

xmlRecord = zr.GetXMLRecord();

}

myRec.load_Xml(xmlRecord);

if (_DbInfo.Charset == "0")//Tinvan record



45



46

{

myRec.Datafields.Clean();

myRec.Datafields.Refresh();

}

CDatafield Df = new CDatafield();

Df.Tag="999";

CSubfield Sf = new CSubfield();

Sf.Code="a";

Sf.Value = _DbInfo.Name;

Df.Subfields.Add(Sf);

myRec.Datafields.Add(Df);

xmlRecord = myRec.OuterXml;

int icheck = _iReceivedCount;

Send_Record(this, xmlRecord);

while (icheck == _iReceivedCount) //while record has

not been added to ResultCache

{

if (threadField.IsAlive)

{

Thread.Sleep(500);

Send_Record(this, xmlRecord);

}

else

{

break;

}

}

Status_Changed(_index, "Running", _iReceivedCount,

_iFoundCount);

}

if (_iFoundCount == 0)

{

Status_Changed(_index, "Not found", _iReceivedCount,

_iFoundCount);

}

else

{

Status_Changed(_index, "Finished", _iReceivedCount,

_iFoundCount);

}

//Done(this);

}

catch (CSZOOMCException czex)

{

Status_Changed(_index, czex.Message, _iReceivedCount,

_iFoundCount);

//Done(this);

}

catch (ThreadAbortException)

{

Status_Changed(_index, "Abort", _iReceivedCount,

_iFoundCount);

}

catch (Exception ex)

{

Status_Changed(_index,ex.Message, _iReceivedCount,

_iFoundCount);

//Done(this);

}

finally

{

Done(this);

}

}



46



47

public int FoundCount

{

get

{

return _iFoundCount;

}

set

{

_iFoundCount = value;

}

}

public int ReceivedCount

{

get

{

return _iReceivedCount;

}

set

{

_iReceivedCount = value;

}

}

public int Index

{

get

{

return _index;

}

}

public string Name

{

get

{

return _DbInfo.Name;

}

}

private void createConnection()

{

ZoomFactory zf = new ZoomFactory();

_zc = zf.CreateZoomConnection(_DbInfo.Host, _DbInfo.Port);

_zqry = zf.CreateZoomQuery(_strQuery, 0);

if (_DbInfo.Name != "")

{

_zc.SetOption("user", _DbInfo.UserID);

_zc.SetOption("pass", _DbInfo.Password);

}

_zc.SetOption("databaseName", _DbInfo.Database);

_zc.SetOption("preferredRecordSyntax", "USmarc");

_zc.SetOption("elementSetName", "F");

}

}

}



3.2.4.4 Lớp ZetMonitor

Lớp ZetMonitor nhận câu lệnh truy vấn và danh sách các cơ sở dữ liệu đích

Z39.50 từ giao diện ngƣời dùng, khởi tạo và quản lý các luồng Z39.50 client,

quản lý bộ đệm kết quả và nhận kết quả trả về từ các luồng Z39.50 client.

47



48

using

using

using

using



System;

System.Collections;

System.Threading;

MarcXmlParser;



namespace ZetPortal

{

public sealed class ZetMonitor

{

public event Monitor_Search_Finished Search_Done;

public event Monitor_First_Record_Found First_Found;

public event Monitor_Send_Status Send_Status;

private int _iCacheSize = 50;

private int _iCacheStepSize = 25;

private int _iMaxThreadArraySize =15;

private int _iLastDatabaseIndex = 0;

private Hashtable _ResultRecords=new Hashtable();

private ArrayList _ThreadArray = new ArrayList();

private int _iTotalFoundCount = 0;

private int _iTotalReceivedCount = 0;

private Hashtable _ZDbRecords = new Hashtable();

private String _RPNQuery = String.Empty;

private bool _isDisposing = false;

private int _index=0;

public int index

{

set

{

_index=value;

}

get

{

return _index;

}

}

public ZetMonitor()

{

}

~ZetMonitor()

{

Object obj = _ThreadArray;

lock (obj)

{

if (_ThreadArray.Count > 0)

{

for (int i = 0; i < _ThreadArray.Count; i++)

{

ZetThread JThread = _ThreadArray[i] as ZetThread;

if (JThread.IsAlive)

{

JThread.Abort();

JThread.Join(500);

}

}

}

}

}

public int CurrentCacheSize

{

get

{

Object obj = _iCacheSize;



48



49

lock(obj)

{

return _iCacheSize;

}

}

}

public int LastDatabaseIndex

{

get

{

Object obj = _iLastDatabaseIndex;

lock (obj)

{

return _iLastDatabaseIndex;

}

}

}

public int CurrentThreadCount

{

get

{

Object obj = _ThreadArray;

lock(obj)

{

return _ThreadArray.Count;

}

}

}

public int CacheSize

{

get

{

Object obj = _iCacheSize;

{

return _iCacheSize;

}

}

set

{

Object obj = _iCacheSize;

lock(obj)

{

_iCacheSize = value;

}

}

}

public int CacheStepSize

{

get

{

Object obj=_iCacheStepSize;

lock (obj)

{

return _iCacheStepSize;

}

}

set

{

Object obj = _iCacheStepSize;

lock(obj)

{

_iCacheStepSize = value;

}



49