http://www.4vsky.com 星际浪子 zh-cn webmaster@loveyuki.com
　　首先介绍一下HTTP协议，HTTP 亦即Hpyer Text Transfer Protocal的缩写，它是现代互联网上最重要的一种网络协议，超文本传输协议位于TCP/IP协议的应用层，是一个面向无连接、简单、快速的C/S结构的协议。HTTP的工作过程大体上分连接、请求、响应和断开连接四个步骤。C#语言对HTTP协议提供了良好的支持，在.NET类库中提供了 WebRequest和WebResponse类，这两个类都包含在System.Net命名空间中，利用这两个类可以实现很多高级的网络功能，本文中多线程文件下载就是利用这两个类实现的。 WebRequest和WebResponse都是抽象基类，因此在程序中不能直接作为对象使用，必须被继承，实际使用中，可根据URI参数中的URI前缀选用它们合适的子类，对于HTTP这类URI,HttpWebRequest和HttpWebResponse类可以用于处理客户程序同WEB服务器之间的HTTP通讯。

　　HttpWebRequest类实现了很多通过HTTP访问WEB服务器上文件的高级功能。HttpWebRequest 类对WebRequest中定义的属性和方法提供支持，HttpWebRequest将发送到Internet资源的公共HTTP标头的值公开为属性，由方法或系统设置，常用的由属性或方法设置的HTTP标头为：接受, 由Accept属性设置, 连接, 由Connection属性和KeepAlive属性设置, Content-Length, 由ContentLength属性设置, Content-Type, 由ContentType属性设置, 范围, 由AddRange方法设置. 实际使用中是将标头信息正确设置后,传递到WEB服务器,WEB服务器根据要求作出回应。]]>
　　首先介绍一下HTTP协议，HTTP 亦即Hpyer Text Transfer Protocal的缩写，它是现代互联网上最重要的一种网络协议，超文本传输协议位于TCP/IP协议的应用层，是一个面向无连接、简单、快速的C/S结构的协议。HTTP的工作过程大体上分连接、请求、响应和断开连接四个步骤。C#语言对HTTP协议提供了良好的支持，在.NET类库中提供了 WebRequest和WebResponse类，这两个类都包含在System.Net命名空间中，利用这两个类可以实现很多高级的网络功能，本文中多线程文件下载就是利用这两个类实现的。 WebRequest和WebResponse都是抽象基类，因此在程序中不能直接作为对象使用，必须被继承，实际使用中，可根据URI参数中的URI前缀选用它们合适的子类，对于HTTP这类URI,HttpWebRequest和HttpWebResponse类可以用于处理客户程序同WEB服务器之间的HTTP通讯。

　　HttpWebRequest类实现了很多通过HTTP访问WEB服务器上文件的高级功能。HttpWebRequest 类对WebRequest中定义的属性和方法提供支持，HttpWebRequest将发送到Internet资源的公共HTTP标头的值公开为属性，由方法或系统设置，常用的由属性或方法设置的HTTP标头为：接受, 由Accept属性设置, 连接, 由Connection属性和KeepAlive属性设置, Content-Length, 由ContentLength属性设置, Content-Type, 由ContentType属性设置, 范围, 由AddRange方法设置. 实际使用中是将标头信息正确设置后,传递到WEB服务器,WEB服务器根据要求作出回应。

　　HttpWebResponse类继承自 WebResponse类，专门处理从WEB服务器返回的HTTP响应，这个类实现了很多方法，具有很多属性，可以全面处理接收到的互联网信息。在 HttpWebResponse类中，对于大多数通用的HTTP标头字段，都有独立的属性与其对应，程序员可以通过这些属性方便的访问位于HTTP接收报文标头字段中的信息，本例中用到的HttpWebResponse类属性为：ContentLength 既接收内容的长度。

　　有了以上的了解后，下面看看这两个类的用法，要创建HttpWebRequest对象，不要直接使用HttpWebRequest的构造函数，而要使用WebRequest.Create方法初始化一个HttpWebRequest实例，如：

Code: 
HttpWebRequest hwr=(HttpWebRequest)WebRequest.Create(http://www.163.com/);

创建了这个对象后，就可以通过HttpWebRequest属性，设置很多HTTP标头字段的内容,如hwr.AddRange(100,1000);设置接收对象的范围为100-1000字节。

　　HttpWebReques对象使用GetResponse()方法时，会返回一个HttpWebResponse对象，为提出HTTP返回报文信息，需要使用HttpWebResponse的GetResponseStream()方法，该方法返回一个Stream对象，可以读取HTTP返回的报文，如：首先定义一个Strean 对象 public System.IO.Stream ns; 然后 ns=hwr.GetResponse ().GetResponseStream ();即可创建Stream对象。有了以上的准备知识后下面开始设计我们的多线程互联网文件的下载程序，首先打开Visual Studio.Net集成开发环境，选择“文件”、“新建”、“项目”，然后选择“Visual C#项目”，在向导右边列表框中选中“Windows应用程序”，输入项目名称，如本例为：httpftp,然后选择“确定”按钮，向导自动生成了一个 Windows应用程序项目。首先打开窗口设计器设计应用程序窗口，增加如下控件：

　　一个列表框 listBox1 三个文本标签 label1-label3 三个文本框 textBox1-textBox3 一个开始接收按钮 button1 设计好的窗口如下图：


打开Form1的代码编辑器，增加如下的命名空间：

Code: 
using System.Net;//网络功能 
using System.IO;//流支持
using System.Threading ;//线程支持
　　

增加如下的程序变量：

Code: 
public bool[] threadw; //每个线程结束标志
public string[] filenamew;//每个线程接收文件的文件名
public int[] filestartw;//每个线程接收文件的起始位置
public int[] filesizew;//每个线程接收文件的大小
public string strurl;//接受文件的URL
public bool hb;//文件合并标志
public int thread;//进程数
 

定义一个HttpFile类，用于管理接收线程，其代码如下：

 

public class HttpFile
    {
        public Form1 formm;
        public int threadh;//线程代号
        public string filename;//文件名
        public string strUrl;//接收文件的URL
        public FileStream fs;
        public HttpWebRequest request;
        public System.IO.Stream ns;
        public byte[] nbytes;//接收缓冲区
        public int nreadsize;//接收字节数
        public HttpFile(Form1 form,int thread)//构造方法
        {
            formm=form;
            threadh=thread;
        }
         ~HttpFile()//析构方法
        {
             formm.Dispose ();
        }
        public void receive()//接收线程
        {
            filename=formm.filenamew[threadh];
            strUrl=formm.strurl;
            ns=null;
            nbytes= new byte[512];
            nreadsize=0;
            formm.listBox1 .Items .Add ("线程"+threadh.ToString ()+"开始接收");
            fs=new FileStream (filename,System.IO.FileMode.Create);
            try
            {
                request=(HttpWebRequest)HttpWebRequest.Create (strUrl);
                //接收的起始位置及接收的长度
                request.AddRange(formm.filestartw [threadh],
                        formm.filestartw [threadh]+formm.filesizew [threadh]);
                ns=request.GetResponse ().GetResponseStream ();//获得接收流
                nreadsize=ns.Read (nbytes,0,512);
                while (nreadsize>0)
                {
                    fs.Write (nbytes,0,nreadsize);
                    nreadsize=ns.Read (nbytes,0,512);
                    formm.listBox1 .Items .Add ("线程"+threadh.ToString ()+"正在接收");
                }
                fs.Close();
                ns.Close ();
            }
            catch (Exception er)
            {
                MessageBox.Show (er.Message );
                fs.Close();
            }
            formm.listBox1 .Items.Add ("进程"+threadh.ToString ()+"接收完毕!");
            formm.threadw[threadh]=true;
        }
    } 该类和Form1类处于统一命名空间，但不包含在Form1类中。下面定义“开始接收”按钮控件的事件响应函数：

 

private void button1_Click(object sender, System.EventArgs e)
        {
            DateTime dt=DateTime.Now;//开始接收时间
            textBox1.Text =dt.ToString ();
            strurl=textBox2.Text .Trim ().ToString ();
            HttpWebRequest request;
            long filesize=0;
            try
            {
                request=(HttpWebRequest)HttpWebRequest.Create (strurl);
                filesize=request.GetResponse ().ContentLength;//取得目标文件的长度
                request.Abort ();
            }
            catch (Exception er)
            {
                MessageBox.Show (er.Message );
            }
            // 接收线程数
            thread=Convert.ToInt32 (textBox4.Text .Trim().ToString (),10);
            //根据线程数初始化数组
            threadw=new bool [thread];
            filenamew=new string [thread];
            filestartw=new int [thread];
            filesizew=new int[thread];
            
            //计算每个线程应该接收文件的大小
            int filethread=(int)filesize/thread;//平均分配
            int filethreade=filethread+(int)filesize%thread;//剩余部分由最后一个线程完成
            //为数组赋值
            for (int i=0;ifalse;//每个线程状态的初始值为假
                filenamew[i]=i.ToString ()+".dat";//每个线程接收文件的临时文件名
                if (i//每个线程接收文件的起始点
                      filesizew[i]=filethread-1;//每个线程接收文件的长度
                    
                }
                else
                {
                    filestartw[i]=filethread*i;
                    filesizew[i]=filethreade-1;
                }
            }
            //定义线程数组，启动接收线程
            Thread[] threadk=new Thread [thread];
            HttpFile[] httpfile=new HttpFile [thread];
            for (int j=0;jnew HttpFile(this,j);
                threadk[j]=new Thread(new ThreadStart (httpfile[j].receive ));
                threadk[j].Start ();
            }
            //启动合并各线程接收的文件线程
            Thread hbth=new Thread (new ThreadStart (hbfile));
            hbth.Start ();

        } 合并文件的线程hbfile定义在Form1类中,定义如下：

public void hbfile()
        {
            while (true)//等待
            {
                hb=true;
                for (int i=0;iif (threadw[i]==false)//有未结束线程，等待
                    {
                        hb=false;
                        Thread.Sleep (100);
                        break;
                    }
                }
                if (hb==true)//所有线程均已结束，停止等待，
                {
                    break;
                }
            }
            FileStream fs;//开始合并
            FileStream fstemp;
            int readfile;
            byte[] bytes=new byte[512];
            fs=new FileStream (textBox3.Text .Trim ().ToString (),System.IO.FileMode.Create);
            for (int k=0;knew FileStream (filenamew[k],System.IO.FileMode .Open);
                while (true)
                {
                    readfile=fstemp.Read (bytes,0,512);
                    if (readfile>0)
                    {
                        fs.Write (bytes,0,readfile);
                    }
                    else
                    {
                        break;
                    }
                }
                fstemp.Close ();
            }
            fs.Close ();
            DateTime dt=DateTime.Now;
            textBox1.Text =dt.ToString ();//结束时间
            MessageBox.Show ("接收完毕!!!");
        } 

 至此，一个多线程下载文件的程序就大功告成了，注意在输入本地文件名时，应按如下格式输入：

“c:\\test\\httpftp\\bin\\d.htm”，因”\”后的字符在C#中是转义字符，线程数并非越大越好，一般5个线程就可以了，该程序在Visual Studio.Net 2002开发环境及Windows xp 操作系统上通过。

]]>http://www.4vsky.com/blogview.asp?logID=35asp.netadmin2007-12-7 17:09:24
说明：控制在发生死锁情况时会话的反应方式。如果两个进程都锁定数据，并且直到其它进程释放自己的锁时，每个进程才能释放自己的锁，即发生死锁情况。

语法：SET DEADLOCK_PRIORITY { LOW | NORMAL | @deadlock_var }]]>
说明：控制在发生死锁情况时会话的反应方式。如果两个进程都锁定数据，并且直到其它进程释放自己的锁时，每个进程才能释放自己的锁，即发生死锁情况。

语法：SET DEADLOCK_PRIORITY { LOW | NORMAL | @deadlock_var }

参数：LOW  指定当前会话为首选死锁牺牲品。Microsoft® SQL Server™ 自动回滚死锁牺牲品的事务，并给客户端应用程序返回 1205 号死锁错误信息。
　　　NORMAL  指定会话返回到默认的死锁处理方法。
　　　@deadlock_var 是指定死锁处理方法的字符变量。如果指定 LOW，则 @deadlock_var 为 3；如果指定 NORMAL，则 @deadlock_var 为 6。

注释：SET DEADLOCK_PRIORITY 的设置是在执行或运行时设置，而不是在分析时设置。

权限：SET DEADLOCK_PRIORITY 权限默认授予所有用户。

 

2. SET LOCK_TIMEOUT

说明：指定语句等待锁释放的毫秒数。

语法：SET LOCK_TIMEOUT timeout_period

参数：timeout_period 是在 Microsoft® SQL Server™ 返回锁定错误前经过的毫秒数。值为 -1（默认值）时表示没有超时期限（即无限期等待）。
　　　   当锁等待超过超时值时，将返回错误。值为 0 时表示根本不等待，并且一遇到锁就返回信息。

注释：在连接开始时，该设置的值为 -1。设置更改后，新设置在其余的连接时间里一直有效。
　　　SET LOCK_TIMEOUT 的设置是在执行或运行时设置，而不是在分析时设置。
　　　READPAST 锁定提示为该 SET 选项提供了另一种方式。

权限：SET LOCK_TIMEOUT 权限默认授予所有用户。

示例：下例将锁超时期限设置为 1,800 毫秒。

　　　SET LOCK_TIMEOUT 1800
　　　GO

 

3. @@LOCK_TIMEOUT

说明：返回当前会话的当前锁超时设置，单位为毫秒。

语法：@@LOCK_TIMEOUT

返回类型：integer

注释：SET LOCK_TIMEOUT 允许应用程序设置语句等待阻塞资源的最长时间。当一条语句已等待超过 LOCK_TIMEOUT 所设置的时间，则被锁住的语句将自动取消，并给应用程序返回一条错误信息。
　　　在一个连接的开始，@@LOCK_TIMEOUT 返回一个 –1值。

示例：下面的示例显示当一个 LOCK_TIMEOUT 值未被设置时的结果集。

　　　SELECT @@LOCK_TIMEOUT
　　　下面是结果集：
　　　----------------
　　　-1

　　　下面的示例设置 LOCK_TIMEOUT 为 1800 毫秒，然后调用 @@LOCK_TIMEOUT。

　　　SET LOCK_TIMEOUT 1800
　　　SELECT @@LOCK_TIMEOUT

　　　下面是结果集：
　　　------------------------------
　　　1800

 

4. SET IDENTITY_INSERT

说明：允许将显式值插入表的标识列中。

语法：SET IDENTITY_INSERT [ database.[ owner.] ] { table } { ON | OFF }

参数：database 是指定的表所驻留的数据库名称。
　　　owner 是表所有者的名称。
　　　table 是含有标识列的表名。

注释：任何时候，会话中只有一个表的 IDENTITY_INSERT 属性可以设置为 ON。如果某个表已将此属性设置为 ON，并且为另一个表发出了 SET IDENTITY_INSERT ON 语句，则 Microsoft® SQL Server™ 返回一个错误信息，指出 SET IDENTITY_INSERT 已设置为 ON 并报告此属性已设置为 ON 的表。
　　　如果插入值大于表的当前标识值，则 SQL Server 自动将新插入值作为当前标识值使用。
　　　SET IDENTITY_INSERT 的设置是在执行或运行时设置，而不是在分析时设置。

权限：执行权限默认授予 sysadmin 固定服务器角色和 db_owner 及 db_ddladmin 固定数据库角色以及对象所有者。

示例：下例创建一个含有标识列的表，并显示如何使用 SET IDENTITY_INSERT 设置填充由 DELETE 语句导致的标识值中的空隙。

　　　-- Create products table.
　　　CREATE TABLE products (id int IDENTITY PRIMARY KEY, product varchar(40))
　　　GO
　　　-- Inserting values into products table.
　　　INSERT INTO products (product) VALUES ('screwdriver')
　　　INSERT INTO products (product) VALUES ('hammer')
　　　INSERT INTO products (product) VALUES ('saw')
　　　INSERT INTO products (product) VALUES ('shovel')
　　　GO

　　　-- Create a gap in the identity values.
　　　DELETE products 
　　　WHERE product = 'saw'
　　　GO

　　　SELECT * 
　　　FROM products
　　　GO

　　　-- Attempt to insert an explicit ID value of 3;
　　　-- should return a warning.
　　　INSERT INTO products (id, product) VALUES(3, 'garden shovel')
　　　GO

　　　-- SET IDENTITY_INSERT to ON.
　　　SET IDENTITY_INSERT products ON
　　　GO

　　　-- Attempt to insert an explicit ID value of 3
　　　INSERT INTO products (id, product) VALUES(3, 'garden shovel')
　　　GO

　　　SELECT * 
　　　FROM products
　　　GO

　　　-- Drop products table.
　　　DROP TABLE products
　　　GO

 

5. SET IMPLICIT_TRANSACTIONS

说明：为连接设置隐性事务模式。

语法：SET IMPLICIT_TRANSACTIONS { ON | OFF }

注释：当设置为 ON 时，SET IMPLICIT_TRANSACTIONS 将连接设置为隐性事务模式。当设置为 OFF 时，则使连接返回到自动提交事务模式。
　　　当连接是隐性事务模式且当前不在事务中时，执行下列语句将启动事务：

　　　ALTER TABLE FETCH REVOKE 
　　　CREATE  GRANT SELECT 
　　　DELETE INSERT TRUNCATE TABLE 
　　　DROP OPEN UPDATE 

　　　如果连接已经在打开的事务中，则上述语句不启动新事务。
　　　对于因为该设置为 ON 而自动打开的事务，用户必须在该事务结束时将其显式提交或回滚。否则当用户断开连接时，事务及其所包含的所有数据更改将回滚。在事务提交后，执行上述任一语句即可启动新事务。
　　　隐性事务模式将保持有效，直到连接执行 SET IMPLICIT_TRANSACTIONS OFF 语句使连接返回到自动提交模式。在自动提交模式下，如果各个语句成功完成则提交。
　　　在进行连接时，SQL Server ODBC 驱动程序和用于 SQL Server 的 Microsoft OLE DB 提供程序自动将 IMPLICIT_TRANSACTIONS 设置为 OFF。对来自 DB-Library 应用程序的连接，SET IMPLICIT_TRANSACTIONS 默认为 OFF。
　　　当 SET ANSI_DEFAULTS 为 ON 时，将启用 SET IMPLICIT_TRANSACTIONS。
　　　SET IMPLICIT_TRANSACTIONS 的设置是在执行或运行时设置，而不是在分析时设置。

示例：下例演示在将 IMPLICIT_TRANSACTIONS 设置为 ON 时显式或隐式启动事务。它使用 @@TRANCOUNT 函数演示打开的事务和关闭的事务。

　　　USE pubs
　　　GO

　　　CREATE table t1 (a int)
　　　GO
　　　INSERT INTO t1 VALUES (1)
　　　GO

　　　PRINT 'Use explicit transaction'
　　　BEGIN TRAN
　　　INSERT INTO t1 VALUES (2)
　　　SELECT 'Tran count in transaction'= @@TRANCOUNT
　　　COMMIT TRAN
　　　SELECT 'Tran count outside transaction'= @@TRANCOUNT
　　　GO

　　　PRINT 'Setting IMPLICIT_TRANSACTIONS ON'
　　　GO
　　　SET IMPLICIT_TRANSACTIONS ON
　　　GO

　　　PRINT 'Use implicit transactions'
　　　GO
　　　-- No BEGIN TRAN needed here.
　　　INSERT INTO t1 VALUES (4)
　　　SELECT 'Tran count in transaction'= @@TRANCOUNT
　　　COMMIT TRAN
　　　SELECT 'Tran count outside transaction'= @@TRANCOUNT
　　　GO

　　　PRINT 'Use explicit transactions with IMPLICIT_TRANSACTIONS ON'
　　　GO
　　　BEGIN TRAN
　　　INSERT INTO t1 VALUES (5)
　　　SELECT 'Tran count in transaction'= @@TRANCOUNT
　　　COMMIT TRAN
　　　SELECT 'Tran count outside transaction'= @@TRANCOUNT
　　　GO

　　　SELECT * FROM t1
　　　GO

　　　-- Need to commit this tran too!
　　　DROP TABLE t1
　　　COMMIT TRAN
　　　GO

 

6. SET NOCOUNT
说明：使返回的结果中不包含有关受 Transact-SQL 语句影响的行数的信息。

语法：SET NOCOUNT { ON | OFF } 

注释：当 SET NOCOUNT 为 ON 时，不返回计数（表示受 Transact-SQL 语句影响的行数）。当 SET NOCOUNT 为 OFF 时，返回计数。
　　　即使当 SET NOCOUNT 为 ON 时，也更新 @@ROWCOUNT 函数。
　　　当 SET NOCOUNT 为 ON 时，将不给客户端发送存储过程中的每个语句的 DONE_IN_PROC 信息。当使用 Microsoft® SQL Server™ 提供的实用工具执行查询时，在 Transact-SQL 语句（如 SELECT、INSERT、UPDATE 和 DELETE）结束时将不会在查询结果中显示"nn rows affected"。
　　　如果存储过程中包含的一些语句并不返回许多实际的数据，则该设置由于大量减少了网络流量，因此可显著提高性能。
　　　SET NOCOUNT 设置是在执行或运行时设置，而不是在分析时设置。

权限：SET NOCOUNT 权限默认授予所有用户。

示例：下例在 osql 实用工具或 SQL Server 查询分析器中执行时，可防止显示有关受影响的行数的信息。

　　　USE pubs
　　　GO
　　　-- Display the count message.
　　　SELECT au_lname 
　　　FROM authors
　　　GO
　　　USE pubs
　　　GO
　　　-- SET NOCOUNT to ON and no longer display the count message.
　　　SET NOCOUNT ON
　　　GO
　　　SELECT au_lname 
　　　FROM authors
　　　GO
　　　-- Reset SET NOCOUNT to OFF.
　　　SET NOCOUNT OFF
　　　GO

 

7. @@ROWCOUNT
说明：返回受上一语句影响的行数。

语法：@@ROWCOUNT

返回类型：integer

注释：任何不返回行的语句将这一变量设置为 0 ，如 IF 语句。

示例：下面的示例执行 UPDATE 语句并用 @@ROWCOUNT 来检测是否有发生更改的行。

　　　UPDATE authors SET au_lname = 'Jones'
　　　WHERE au_id = '999-888-7777'
　　　IF @@ROWCOUNT = 0
　　　   print 'Warning: No rows were updated'

 

8. SET ROWCOUNT

说明：使 Microsoft® SQL Server™ 在返回指定的行数之后停止处理查询。 

语法：SET ROWCOUNT { number | @number_var } 

参数：number | @number_var 是在停止给定查询之前要处理的行数（整数）。

注释：建议将当前使用 SET ROWCOUNT 的 DELETE、INSERT 和 UPDATE 语句重新编写为使用 TOP 语法。有关更多信息，请参见 DELETE、INSERT 或 UPDATE。
　　　对于在远程表和本地及远程分区视图上执行的 INSERT、UPDATE 和 DELETE 语句，忽略 SET ROWCOUNT 选项设置。
　　　若要关闭该选项（以便返回所有的行），请将 SET ROWCOUNT 指定为 0。
　　　说明  设置 SET ROWCOUNT 选项将使大多数 Transact-SQL 语句在已受指定数目的行影响后停止处理。这包括触发器和 INSERT、UPDATE 及 DELETE 等数据修改语句。ROWCOUNT 选项对动态游标无效，但限制键集的行集和不感知游标。使用该选项时应谨慎，它主要与 SELECT 语句一起使用。
　　　如果行数的值较小，则 SET ROWCOUNT 替代 SELECT 语句 TOP 关键字。
　　　SET ROWCOUNT 的设置是在执行或运行时设置，而不是在分析时设置。

权限：SET ROWCOUNT 权限默认授予所有用户。

示例：SET ROWCOUNT 在指定的行数后停止处理。在下例中，注意有 x 行满足预付款少于或等于 $5,000 的条件；但是，从更新所返回的行数中可以看出并非所有的行都得到处理。ROWCOUNT 影响所有的 Transact-SQL 语句。

　　　USE pubs
　　　GO
　　　SELECT count(*) AS Cnt
　　　FROM titles 
　　　WHERE advance >= 5000
　　　GO

　　　下面是结果集：

　　　Cnt       
　　　----------- 
　　　11          

　　　(1 row(s) affected)

　　　现在，将 ROWCOUNT 设置为 4，并更新预付款等于或大于 $5,000 的所有行。

　　　-- SET ROWCOUNT to 4.
　　　SET ROWCOUNT 4
　　　GO
　　　UPDATE titles
　　　SET advance = 5000
　　　WHERE advance >= 5000
　　　GO

 

9. SET TRANSACTION ISOLATION LEVEL
说明：控制由连接发出的所有 Microsoft® SQL Server™ SELECT 语句的默认事务锁定行为。

语法：SET TRANSACTION ISOLATION LEVEL
　　　{ READ COMMITTED
　　　    | READ UNCOMMITTED
　　　    | REPEATABLE READ
　　　    | SERIALIZABLE 
　　　}

参数：READ COMMITTED 指定在读取数据时控制共享锁以避免脏读，但数据可在事务结束前更改，从而产生不可重复读取或幻像数据。该选项是 SQL Server 的默认值。
　　　READ UNCOMMITTED 执行脏读或 0 级隔离锁定，这表示不发出共享锁，也不接受排它锁。当设置该选项时，可以对数据执行未提交读或脏读；在事务结束前可以更改数据内的数值，行也可以出现在数据集中或从数据集消失。该选项的作用与在事务内所有语句中的所有表上设置 NOLOCK 相同。这是四个隔离级别中限制最小的级别。
　　　REPEATABLE READ 锁定查询中使用的所有数据以防止其他用户更新数据，但是其他用户可以将新的幻像行插入数据集，且幻像行包括在当前事务的后续读取中。因为并发低于默认隔离级别，所以应只在必要时才使用该选项。
　　　SERIALIZABLE 在数据集上放置一个范围锁，以防止其他用户在事务完成之前更新数据集或将行插入数据集内。这是四个隔离级别中限制最大的级别。因为并发级别较低，所以应只在必要时才使用该选项。该选项的作用与在事务内所有 SELECT 语句中的所有表上设置 HOLDLOCK 相同。

注释：一次只能设置这些选项中的一个，而且设置的选项将一直对那个连接保持有效，直到显式更改该选项为止。这是默认行为，除非在语句的 FROM 子句中在表级上指定优化选项。
　　　SET TRANSACTION ISOLATION LEVEL 的设置是在执行或运行时设置，而不是在分析时设置。

示例：下例为会话设置 TRANSACTION ISOLATION LEVEL。对于每个后续 Transact-SQL 语句，SQL Server 将所有共享锁一直控制到事务结束为止。

　　　SET TRANSACTION ISOLATION LEVEL REPEATABLE READ
　　　GO
　　　BEGIN TRANSACTION
　　　SELECT * FROM publishers
　　　SELECT * FROM authors
　　　...
　　　COMMIT TRANSACTION

 

10. SET XACT_ABORT

说明：指定当 Transact-SQL 语句产生运行时错误时，Microsoft® SQL Server™ 是否自动回滚当前事务。

语法：SET XACT_ABORT { ON | OFF }

注释：当 SET XACT_ABORT 为 ON 时，如果 Transact-SQL 语句产生运行时错误，整个事务将终止并回滚。为 OFF 时，只回滚产生错误的 Transact-SQL 语句，而事务将继续进行处理。编译错误（如语法错误）不受 SET XACT_ABORT 的影响。
　　　对于大多数 OLE DB 提供程序（包括 SQL Server），隐性或显式事务中的数据修改语句必须将 XACT_ABORT 设置为 ON。唯一不需要该选项的情况是提供程序支持嵌套事务时。有关更多信息，请参见分布式查询和分布式事务。 
　　　SET XACT_ABORT 的设置是在执行或运行时设置，而不是在分析时设置。

示例：下例导致在含有其它 Transact-SQL 语句的事务中发生违反外键错误。在第一个语句集中产生错误，但其它语句均成功执行且事务成功提交。在第二个语句集中，SET XACT_ABORT 设置为 ON。这导致语句错误使批处理终止，并使事务回滚。 

　　　CREATE TABLE t1 (a int PRIMARY KEY)
　　　CREATE TABLE t2 (a int REFERENCES t1(a))
　　　GO
　　　INSERT INTO t1 VALUES (1)
　　　INSERT INTO t1 VALUES (3)
　　　INSERT INTO t1 VALUES (4)
　　　INSERT INTO t1 VALUES (6)
　　　GO
　　　SET XACT_ABORT OFF
　　　GO
　　　BEGIN TRAN
　　　INSERT INTO t2 VALUES (1)
　　　INSERT INTO t2 VALUES (2) /* Foreign key error */
　　　INSERT INTO t2 VALUES (3)
　　　COMMIT TRAN
　　　GO

　　　SET XACT_ABORT ON
　　　GO

　　　BEGIN TRAN
　　　INSERT INTO t2 VALUES (4)
　　　INSERT INTO t2 VALUES (5) /* Foreign key error */
　　　INSERT INTO t2 VALUES (6)
　　　COMMIT TRAN
　　　GO

　　　/* Select shows only keys 1 and 3 added. 
　　　   Key 2 insert failed and was rolled back, but
　　　   XACT_ABORT was OFF and rest of transaction
　　　   succeeded.
　　　   Key 5 insert error with XACT_ABORT ON caused
　　　   all of the second transaction to roll back. */

　　　SELECT * 
　　　FROM t2
　　　GO

　　　DROP TABLE t2
　　　DROP TABLE t1
　　　GO

]]>http://www.4vsky.com/blogview.asp?logID=34sqlserveradmin2007-9-30 16:54:36]]>]]>http://www.4vsky.com/blogview.asp?logID=33sqlserveradmin2007-9-7 11:45:53https://www.microsoft.com/technet/prodtechnol/WindowsServer2003 ... 8-4c78-8bc1-45c3859fc163.mspx?mfr=true]]>http://www.4vsky.com/blogview.asp?logID=31aspadmin2007-7-4 15:17:15php.ini -> c:\windows

单独建立应用程序池]]>php.ini -> c:\windows

单独建立应用程序池]]>http://www.4vsky.com/blogview.asp?logID=30phpadmin2007-3-22 19:33:47
    但当以上操作放到多线程中并发处理时会出现问题：某线程select了一条记录但还没来得及update时，另一个线程仍然可能会进来select到同一条记录。

]]>
    但当以上操作放到多线程中并发处理时会出现问题：某线程select了一条记录但还没来得及update时，另一个线程仍然可能会进来select到同一条记录。


一般解决办法就是使用锁和事物的联合机制：

如： 

1. 把select放在事务中, 否则select完成, 锁就释放了
2. 要阻止另一个select , 则要手工加锁, select 默认是共享锁, select之间的共享锁是不冲突的, 所以, 如果只是共享锁, 即使锁没有释放, 另一个select一样可以下共享锁, 从而select出数据 


BEGIN TRAN
SELECT * FROM table WITH(TABLOCKX) 


或者 SELECT * FROM table WITH(UPDLOCK, READPAST) 具体情况而定。

UPDATE ....
COMMIT TRAN


锁描述：
HOLDLOCK：将共享锁保留到事务完成，而不是在相应的表、行或数据页不再需要时就立即释放锁。HOLDLOCK 等同于 SERIALIZABLE。 
NOLOCK 不要发出共享锁，并且不要提供排它锁。当此选项生效时，可能会读取未提交的事务或一组在读取中间回滚的页面。有可能发生脏读。仅应用于 SELECT 语句。 
PAGLOCK：在通常使用单个表锁的地方采用页锁。 
READCOMMITTED：用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQL Server 2000 在此隔离级别上操作。 
READPAST：跳过锁定行。此选项导致事务跳过由其它事务锁定的行（这些行平常会显示在结果集内），而不是阻塞该事务，使其等待其它事务释放在这些行上的锁。 READPAST 锁提示仅适用于运行在提交读隔离级别的事务，并且只在行级锁之后读取。仅适用于 SELECT 语句。 
READUNCOMMITTED：等同于 NOLOCK。 
REPEATABLEREAD：用与运行在可重复读隔离级别的事务相同的锁语义执行扫描。 
ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。 
SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于 HOLDLOCK。 
TABLOCK：使用表锁代替粒度更细的行级锁或页级锁。在语句结束前，SQL Server 一直持有该锁。但是，如果同时指定 HOLDLOCK，那么在事务结束之前，锁将被一直持有。 
TABLOCKX 使用表的排它锁。该锁可以防止其它事务读取或更新表，并在语句或事务结束前一直持有。 
UPDLOCK：读取表时使用更新锁，而不使用共享锁，并将锁一直保留到语句或事务的结束。UPDLOCK：的优点是允许您读取数据（不阻塞其它事务）并在以后更新数据，同时确保自从上次读取数据后数据没有被更改。 
XLOCK：使用排它锁并一直保持到由语句处理的所有数据上的事务结束时。可以使用 PAGLOCK 或 TABLOCK 指定该锁，这种情况下排它锁适用于适当级别的粒度。

]]>http://www.4vsky.com/blogview.asp?logID=29sqlserveradmin2007-1-10 16:19:41 SET TRANSACTION ISOLATION LEVEL SERIALIZABLE    --防止其他事务更新 ,但可读取
  begin tran
  select @a = a from a where id = 1
    waitfor delay ''00:00:10'']]> SET TRANSACTION ISOLATION LEVEL SERIALIZABLE    --防止其他事务更新 ,但可读取
  begin tran
  select @a = a from a where id = 1
    waitfor delay '00:00:10'
    update a set a = a + 1 where id = 1
  commit tran
  select @a = a from a where id = 1
  print @a

参数
READ COMMITTED

指定在读取数据时控制共享锁以避免脏读，但数据可在事务结束前更改，从而产生不可重复读取或幻像数据。该选项是 SQL Server 的默认值。

READ UNCOMMITTED

执行脏读或 0 级隔离锁定，这表示不发出共享锁，也不接受排它锁。当设置该选项时，可以对数据执行未提交读或脏读；在事务结束前可以更改数据内的数值，行也可以出现在数据集中或从数据集消失。该选项的作用与在事务内所有语句中的所有表上设置 NOLOCK 相同。这是四个隔离级别中限制最小的级别。

REPEATABLE READ

锁定查询中使用的所有数据以防止其他用户更新数据，但是其他用户可以将新的幻像行插入数据集，且幻像行包括在当前事务的后续读取中。因为并发低于默认隔离级别，所以应只在必要时才使用该选项。

SERIALIZABLE

在数据集上放置一个范围锁，以防止其他用户在事务完成之前更新数据集或将行插入数据集内。这是四个隔离级别中限制最大的级别。因为并发级别较低，所以应只在必要时才使用该选项。该选项的作用与在事务内所有 SELECT 语句中的所有表上设置 HOLDLOCK 相同。
]]>http://www.4vsky.com/blogview.asp?logID=28sqlserveradmin2007-1-10 15:50:12]]>]]>http://www.4vsky.com/blogview.asp?logID=27asp.netadmin2006-12-18 17:48:47
<script> function addline(content){ newline=document.all.test.insertRow(); newline.insertCell().innerHTML=''<input type="text" name="tt[]"><input type="button" value="删除此行" onclick="del()">'' } function del(){ document.all.test.deleteRow(window.event.srcElement.parentElement.parentElement.rowIndex); } </script>]]>
<script> function addline(content){ newline=document.all.test.insertRow(); newline.insertCell().innerHTML='<input type="text" name="tt[]"><input type="button" value="删除此行" onclick="del()">' } function del(){ document.all.test.deleteRow(window.event.srcElement.parentElement.parentElement.rowIndex); } </script>]]>http://www.4vsky.com/blogview.asp?logID=26javascriptadmin2006-12-14 11:48:40
    查看当前进程,或死锁进程,并能自动杀掉死进程

    因为是针对死的,所以如果有死锁进程,只能查看死锁进程]]>
    查看当前进程,或死锁进程,并能自动杀掉死进程

    因为是针对死的,所以如果有死锁进程,只能查看死锁进程
    当然,你可以通过参数控制,不管有没有死锁,都只查看死锁进程

    感谢: caiyunxia,jiangopen 两位提供的参考信息

--邹建 2004.4--*/

/**//*--调用示例

    exec p_lockinfo
--*/
create proc p_lockinfo
@kill_lock_spid bit=1,        --是否杀掉死锁的进程,1 杀掉, 0 仅显示
@show_spid_if_nolock bit=1    --如果没有死锁的进程,是否显示正常进程信息,1 显示,0 不显示
as
set nocount on
declare @count int,@s nvarchar(1000),@i int
select id=identity(int,1,1),标志,
    进程ID=spid,线程ID=kpid,块进程ID=blocked,数据库ID=dbid,
    数据库名=db_name(dbid),用户ID=uid,用户名=loginame,累计CPU时间=cpu,
    登陆时间=login_time,打开事务数=open_tran,    进程状态=status,
    工作站名=hostname,应用程序名=program_name,工作站进程ID=hostprocess,
    域名=nt_domain,网卡地址=net_address
into #t from(
    select 标志='死锁的进程',
        spid,kpid,a.blocked,dbid,uid,loginame,cpu,login_time,open_tran,
        status,hostname,program_name,hostprocess,nt_domain,net_address,
        s1=a.spid,s2=0
    from master..sysprocesses a join (
        select blocked from master..sysprocesses group by blocked
        )b on a.spid=b.blocked where a.blocked=0
    union all
    select '|_牺牲品_>',
        spid,kpid,blocked,dbid,uid,loginame,cpu,login_time,open_tran,
        status,hostname,program_name,hostprocess,nt_domain,net_address,
        s1=blocked,s2=1
    from master..sysprocesses a where blocked<>0
)a order by s1,s2

select @count=@@rowcount,@i=1

if @count=0 and @show_spid_if_nolock=1
begin
    insert #t
    select 标志='正常的进程',
        spid,kpid,blocked,dbid,db_name(dbid),uid,loginame,cpu,login_time,
        open_tran,status,hostname,program_name,hostprocess,nt_domain,net_address
    from master..sysprocesses
    set @count=@@rowcount
end

if @count>0
begin
    create table #t1(id int identity(1,1),a nvarchar(30),b Int,EventInfo nvarchar(255))
    if @kill_lock_spid=1
    begin
        declare @spid varchar(10),@标志 varchar(10)
        while @i<=@count
        begin
            select @spid=进程ID,@标志=标志 from #t where id=@i
            insert #t1 exec('dbcc inputbuffer('+@spid+')')
            if @@rowcount=0 insert #t1(a) values(null)
            if @标志='死锁的进程' exec('kill '+@spid)
            set @i=@i+1
        end
    end
    else
        while @i<=@count
        begin
            select @s='dbcc inputbuffer('+cast(进程ID as varchar)+')' from #t where id=@i
            insert #t1 exec(@s)
            if @@rowcount=0 insert #t1(a) values(null)
            set @i=@i+1
        end
    select a.*,进程的SQL语句=b.EventInfo
    from #t a join #t1 b on a.id=b.id
    order by 进程ID
end
set nocount off

GO


--查看
if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[sp_who_lock]') and OBJECTPROPERTY(id, N'IsProcedure') = 1)
drop procedure [dbo].[sp_who_lock]
GO
use master
go
create procedure sp_who_lock
as
begin
declare @spid int,@bl int,
    @intTransactionCountOnEntry     int,
        @intRowcount             int,
        @intCountProperties         int,
        @intCounter             int

    create table #tmp_lock_who (
    id int identity(1,1),
    spid smallint,
    bl smallint)
    
    IF @@ERROR<>0 RETURN @@ERROR
    
    insert into #tmp_lock_who(spid,bl) select  0 ,blocked
      from (select * from sysprocesses where  blocked>0 ) a 
      where not exists(select * from (select * from sysprocesses where  blocked>0 ) b 
      where a.blocked=spid)
      union select spid,blocked from sysprocesses where  blocked>0

    IF @@ERROR<>0 RETURN @@ERROR    
     
-- 找到临时表的记录数
    select     @intCountProperties = Count(*),@intCounter = 1
    from #tmp_lock_who
    
    IF @@ERROR<>0 RETURN @@ERROR    
    
    if    @intCountProperties=0
        select '现在没有阻塞和死锁信息' as message

-- 循环开始
while @intCounter <= @intCountProperties
begin
-- 取第一条记录
        select     @spid = spid,@bl = bl
        from #tmp_lock_who where Id = @intCounter 
    begin
     if @spid =0 
            select '引起数据库死锁的是: '+ CAST(@bl AS VARCHAR(10)) + '进程号,其执行的SQL语法如下'
 else
            select '进程号SPID：'+ CAST(@spid AS VARCHAR(10))+ '被' + '进程号SPID：'+ CAST(@bl AS VARCHAR(10)) +'阻塞,其当前进程执行的SQL语法如下'
 DBCC INPUTBUFFER (@bl )
    end    

-- 循环指针下移
    set @intCounter = @intCounter + 1
end


drop table #tmp_lock_who

return 0
end
]]>http://www.4vsky.com/blogview.asp?logID=25sqlserveradmin2006-12-12 11:26:33