SQL Server如何处理死锁
SQL Server如何处理死锁
【IT168 专稿】死锁产生的情形是由于两个事务彼此互相等待对方放弃各自的锁造成的。
当出现这种情况时，SQL Server会自动选择一个关掉进程，允许另一个进程继续执行来结束死锁。关闭的事务会被回滚并抛出一个错误的消息发送给执行该进程的用户。一般来说，事务需要最少数量的开销来回滚锁撤销的事务。
这篇文章将解释如何以一种友好的方式来处理死锁问题。
死锁
事务A企图更新表1并且同时从第2张表执行读或更新操作，而事务B其它更新表2并同时从表1执行读或更新操作。再这种情形下，事务A打开锁以便事务B需要完成它的任务，反之亦然;这样事务都不能完成直到其它事务释放锁为止。
死锁的解决方案
下面的示例展示了两个事务之间造成死锁的情形。
事务 A
BEGIN TRANSACTION
UPDATE Customer SET LastName ='John'WHERE CustomerId=111
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Orders SET CustomerId =1WHERE OrderId =221
COMMIT TRANSACTION
事务B
BEGIN TRANSACTION
UPDATE Orders SET ShippingId =12WHERE OrderId =221
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Customer SET FirstName ='Mike'WHERE CustomerId=111
COMMIT TRANSACTION
如果两个事务都在同一时间执行，那么事务A会锁住并更新Customer表，而此时事务B会锁住并更新Orders表。延迟5 ms之后，事务A会寻找锁住的
Orders表而该表已经被事务B锁住，此时，事务B会寻找被事务A锁住的Customer 表。因此，两个事务一直都不能执行，死锁产生了，并且SQL server会为放弃的事务返回一个错误消息1205.
(1 row(s) affected)
Msg 1205, Level13, State 45, Line 5
Transaction (Process ID 52) was deadlocked on lock resources with another process and has been chosen as the deadlock victim.
Rerun the transaction.
但是如果你不想看到系统默认的处理行为(放弃事务)应该如何实现呢?你可以改变它吗?是的，可以，通过重写下面展示的事务A和事务B即可实现。
事务 A
RETRY: -- Label RETRY
BEGIN TRANSACTION
BEGIN TRY
UPDATE Customer SET LastName ='John'WHERE CustomerId=111
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Orders SET CustomerId =1WHERE OrderId =221
COMMIT TRANSACTION
END TRY
BEGIN CATCH
PRINT'Rollback Transaction'
ROLLBACK TRANSACTION
IF ERROR_NUMBER() =1205-- Deadlock Error Number
BEGIN
WAITFOR DELAY '00:00:00.05'-- Wait for 5 ms
GOTO RETRY -- Go to Label RETRY
END
END CATCH
事务 B
RETRY: -- Label RETRY
BEGIN TRANSACTION
BEGIN TRY
UPDATE Orders SET ShippingId =12Where OrderId =221
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Customer SET FirstName ='Mike'WHERE CustomerId=111
COMMIT TRANSACTION
END TRY
BEGIN CATCH
PRINT'Rollback Transaction'
ROLLBACK TRANSACTION
IF ERROR_NUMBER() =1205-- Deadlock Error Number
BEGIN
WAITFOR DELAY '00:00:00.05'-- Wait for 5 ms
GOTO RETRY -- Go to Label RETRY
END
END CATCH
这里我在两个事务的开始时使用了标签RETRY来实现。TRY/CATCH 方法用来在事务中处理异常。如果写在TRY块中的代码失败了，控制器会自动地跳转到CATCH块，让事务回滚，并且如果异常是由于死锁 (Error_Number 1205)而产生的异常，事务将等待5毫秒。这里使用延迟是因为其它的事务(未放弃的事务)在延迟时间内能够完成它的操作并释放自己锁住的表。你可以根据事务的大小来增加延迟的时间。延迟之后，通过使用下面的元素事务开始从开始标签执行(RETRY: Label RETRY在事务的开始处)：
GOTO RETRY -- Go to Label RETRY
该语句用于转移名为RETRY的控制标签(开始处)。
现在，同时执行事务A和事务B。两个事务将会执行成功。再次看看出现事务异常发生的地方将会得到不通的信息。
(1 row(s) affected)
Rollback Transaction
(1 row(s) affected)
//(1 row(s) affected)
使用RetryCounter
现在，我猜测你已经了解了在不放弃另一个事务的情况下如何处理死锁问题。现在咱们将话题转移到下一个关于死锁的话题。想象一下，如果有多于两个的进程需要同时对表Customer和 Orders表执行读或更新操作。下面，我已经修改了这两个事务，以展示如何使用RetryCounter来解决这个问题。
事务A
DECLARE@RetryCounter INT
SET@RetryCounter=1
RETRY: -- Label RETRY
BEGIN TRANSACTION
BEGIN TRY
UPDATE Customer SET LastName ='John'WHERE CustomerId=111
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Orders SET CustomerId =1WHERE OrderId =221
COMMIT TRANSACTION
END TRY
BEGIN CATCH
PRINT'Rollback Transaction'
ROLLBACK TRANSACTION
DECLARE@DoRetry bit; -- Whether to Retry transaction or not
DECLARE@ErrorMessage varchar(500)
SET@doRetry=0;
SET@ErrorMessage= ERROR_MESSAGE()
IF ERROR_NUMBER() =1205-- Deadlock Error Number
BEGIN
SET@doRetry=1; -- Set @doRetry to 1 only for Deadlock END
IF@DoRetry=1
BEGIN
SET@RetryCounter=@RetryCounter+1-- Increment Retry Counter By one
IF(@RetryCounter>3) -- Check whether Retry Counter reached to 3
BEGIN
RAISERROR(@ErrorMessage, 18, 1) -- Raise Error Message if -- still deadlock occurred after three retries END
ELSE
BEGIN
WAITFOR DELAY '00:00:00.05'-- Wait for 5 ms
GOTO RETRY -- Go to Label RETRY
END
END
ELSE
BEGIN
RAISERROR(@ErrorMessage, 18, 1)
END
//END CATCH
事务 B
DECLARE@RetryCounter INT
SET@RetryCounter=1
RETRY: -- Label RETRY
BEGIN TRANSACTION
BEGIN TRY
UPDATE Orders SET ShippingId =12Where OrderId =221
WAITFOR DELAY '00:00:05'-- Wait for 5 ms
UPDATE Customer SET FirstName ='Mike'WHERE CustomerId=111
COMMIT TRANSACTION
END TRY
BEGIN CATCH
PRINT'Rollback Transaction'
ROLLBACK TRANSACTION
DECLARE@DoRetry bit; -- Whether to Retry transaction or not
DECLARE@ErrorMessage varchar(500)
SET@doRetry=0;
SET@ErrorMessage= ERROR_MESSAGE()
IF ERROR_NUMBER() =1205-- Deadlock Error Number
BEGIN
SET@doRetry=1; -- Set @doRetry to 1 only for Deadlock END
IF@DoRetry=1
BEGIN
SET@RetryCounter=@RetryCounter+1-- Increment Retry Counter By one
IF(@RetryCounter>3) -- Check whether Retry Counter reached to 3
BEGIN
RAISERROR(@ErrorMessage, 18, 1) -- Raise Error Message
-- if still deadlock occurred after three retries END
ELSE
BEGIN
WAITFOR DELAY '00:00:00.05'-- Wait for 5 ms
GOTO RETRY -- Go to Label RETRY
END
END
ELSE
BEGIN
RAISERROR(@ErrorMessage, 18, 1)
END
//END CATCH
如果事务失败是由于死锁造成的(Error_Number 1205)，这里使用RetryCounter变量对于事务再次执行有一定的变化。在本示例中，如果事务是因为死锁造成的，则事务能够试着执行三次。这种场景对于如果事务正在寻找一个需要很长时间才能完成的操作是非常有用的。因此，事务可以尝试三次来检查是否该死锁是可用的。
********************************************
SQL code
*--处理死锁
查看当前进程,或死锁进程,并能自动杀掉死进程
因为是针对死的,所以如果有死锁进程,只能查看死锁进程
当然,你可以通过参数控制,不管有没有死锁,都只查看死锁进程
--邹建 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
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=0and@show_spid_if_nolock=1
begin
insert #t
select标志='正常的进程',
spid,kpid,blocked,dbid,db_name(dbid),uid,loginame,cpu,login_tim e,
open_tran,status,hostname,program_name,hostprocess,nt_domain,ne t_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@标志='死锁的进程'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)
set@i=@i+1
end
select a.*,进程的SQL语句=b.EventInfo
from #t a join #t1 b on a.id=b.id
end
go
**********************************
本主题介绍了 SQL Server 2008 中的更改跟踪函数，以及如何使用它们获取在数据库中所做的更改以及有关这些更改的信息。
关于更改跟踪函数
应用程序可以使用以下函数来获取在数据库中所做的更改以及有关这些更改的信息：
CHANGETABLE(CHANGES …) 函数
此行集函数用于查询更改信息。该函数查询内部更改跟踪表中存储的数
据。该函数返回的结果集中包含已更改的行的主键和其他更改信息，例如，操作、更新的列以及行版本。
CHANGETABLE(CHANGES …) 将上次同步版本作为参数。上次同步版本的语义如下所示：
?进行调用的客户端已获取更改，并知道直至上次同步版本（含该版本）所做的所有更改。
?因此，CHANGETABLE(CHANGES …) 返回在上次同步版本之后进行的所有更改。
下图说明了如何使用CHANGETABLE(CHANGES …) 获取更改。
CHANGE_TRACKING_CURRENT_VERSION() 函数
用于获取当前版本，以供下次查询更改时使用。该版本表示上次提交的事
务的版本。
CHANGE_TRACKING_MIN_V ALID_VERSION() 函数
用于获取客户端能够具有的并且仍能从 CHANGETABLE() 获取有效结果的
最低有效版本。客户端应将上次同步版本与此函数返回的值进行对照检
查。如果上次同步版本低于此函数返回的版本，客户端将无法从
CHANGETABLE() 获取有效结果，而必须重新进行初始化。
获取初始数据
在应用程序第一次获取更改之前，应用程序必须发送查询以获取初始数据和同步版本。应用程序必须直接从表中获取相应的数据，然后使用
CHANGE_TRACKING_CURRENT_VERSION() 获取初始版本。第一次获取更改时，会将此版本传递给CHANGETABLE(CHANGES …)。
下面的示例说明了如何获取初始同步版本和初始数据集。
-- Obtain the current synchronization version. This will be used next time that changes are obtained.
SET@synchronization_version= CHANGE_TRACKING_CURRENT_VERSION(); -- Obtain initial data set.
SELECT P.ProductID, https://www.360docs.net/doc/2611078698.html,, P.ListPrice FROM SalesLT.Product AS P
使用更改跟踪函数获取更改
若要获取表中更改的行以及有关这些更改的信息，请使用
CHANGETABLE(CHANGES…)。例如，下面的查询获取 SalesLT.Product 表的更改。
SELECT CT.ProductID, CT.SYS_CHANGE_OPERATION,
CT.SYS_CHANGE_COLUMNS, CT.SYS_CHANGE_CONTEXT
FROM CHANGETABLE(CHANGES SalesLT.Product,
@last_synchronization_version) AS CT
通常，客户端需要获取行的最新数据，而不仅仅是行的主键。因此，应用程序将来自CHANGETABLE(CHANGES …) 的结果与用户表中的数据联接在一起。例如，下面的查询与 SalesLT.Product 表联接在一起以获取 Name 和 ListPrice 列的值。请注意，本例中使用了 OUTER JOIN。若要确保返回有关从用户表中删除的那些行的更改信息，则必须使用此运算符。
SELECT CT.ProductID, https://www.360docs.net/doc/2611078698.html,, P.ListPrice,
CT.SYS_CHANGE_OPERATION, CT.SYS_CHANGE_COLUMNS,
CT.SYS_CHANGE_CONTEXT
FROM SalesLT.Product AS P RIGHT OUTER JOIN CHANGETABLE(CHANGES SalesLT.Product, @last_synchronization_version) AS CT
ON P.ProductID = CT.ProductID
若要获取在下次更改枚举中使用的版本，请使用
CHANGE_TRACKING_CURRENT_VERSION()，如下面的示例所示。
SET@synchronization_version= CHANGE_TRACKING_CURRENT_VERSION()
当应用程序获取更改时，它必须同时使用CHANGETABLE(CHANGES…) 和CHANGE_TRACKING_CURRENT_VERSION()，如下面的示例所示。
-- Obtain the current synchronization version. This will be used the next time CHANGETABLE(CHANGES...) is called.
SET@synchronization_version= CHANGE_TRACKING_CURRENT_VERSION();
-- Obtain incremental changes by using the synchronization version obtained the last time the data was synchronized.
SELECT CT.ProductID, https://www.360docs.net/doc/2611078698.html,, P.ListPrice,
CT.SYS_CHANGE_OPERATION, CT.SYS_CHANGE_COLUMNS,
CT.SYS_CHANGE_CONTEXT
FROM SalesLT.Product AS P RIGHT OUTER JOIN CHANGETABLE(CHANGES SalesLT.Product, @last_synchronization_version) AS CT
ON P.ProductID = CT.ProductID
版本号
启用了更改跟踪的数据库具有一个版本计数器；在对启用了更改跟踪的表进行更改时，该计数器会随之递增。每个更改的行都有一个关联的版本号。将请求发送到应用程序以查询更改时，将调用一个函数以提供版本号。该函数返回在该版本之后所做的所有更改的相关信息。从某种意义上讲，更改跟踪版本在概念上与rowversion数据类型类似。
验证上次同步版本
更改的相关信息将保留有限的一段时间。时间长度是由 CHANGE_RETENTION 参数控制的，可以将该参数指定为 ALTER DATABASE 的一部分。
请注意，为 CHANGE_RETENTION 指定的时间决定了所有应用程序必须每隔多长时间从数据库中请求一次更改。如果应用程序使用的
last_synchronization_version值早于表的最低有效同步版本，该应用程序将无法执行有效的更改枚举。这是因为，可能已清除了某些更改信息。在应用程序使用CHANGETABLE(CHANGES …) 获取更改之前，该应用程序必须验证计划传递给CHANGETABLE(CHANGES …) 的last_synchronization_version值。如果
last_synchronization_version值无效，该应用程序必须重新初始化所有数据。
下面的示例说明了如何验证每个表的 last_synchronization_version 值的有
效性。
-- Check individual table.
IF (@last_synchronization_version<
CHANGE_TRACKING_MIN_VALID_VERSION( OBJECT_ID('SalesLT.Product'))) BEGIN
-- Handle invalid version and do not enumerate changes.
-- Client must be reinitialized.
END
正如下面的示例所示，可以对照数据库中的所有表检查
last_synchronization_version 值的有效性。
代码
-- Check all tables with change tracking enabled
IF EXISTS ( SELECT COUNT(*) FROM sys.change_tracking_tables WHERE min_valid_version >@last_synchronization_version ) BEGIN
-- Handle invalid version & do not enumerate changes
-- Client must be reinitialized
END
使用列跟踪
通过使用列跟踪，应用程序可以仅获取已更改的列数据，而不是获取整个行。例如，请考虑以下情况：某个表包含一个或多个较大但很少更改的列，并且还包含其他经常更改的列。如果未使用列跟踪，应用程序只能确定某一行已更改并且必须同步所有数据（包括大型列数据）。但是，通过使用列跟踪，应用程序可以确定是否更改了大型列数据，并且仅同步已更改的数据。
列跟踪信息出现在CHANGETABLE(CHANGES …) 函数返回的
SYS_CHANGE_COLUMNS 列中。
可以使用列跟踪，以便为未更改的列返回 NULL。如果可以将列更改为 NULL，则必须返回一个单独的列以指示是否更改了该列。
在下面的示例中，如果 CT_ThumbnailPhoto 列未更改，则为该列返回 NULL。该列本身也可能为 NULL，因为已将其更改为 NULL；应用程序可以使用
CT_ThumbNailPhoto_Changed 列来确定是否更改了该列。
DECLARE@PhotoColumnId int=COLUMNPROPERTY(
OBJECT_ID('SalesLT.Product'),'ThumbNailPhoto', 'ColumnId')
SELECT
CT.ProductID, https://www.360docs.net/doc/2611078698.html,, P.ListPrice, -- Always obtain values.
CASE
WHEN CHANGE_TRACKING_IS_COLUMN_IN_MASK(
@PhotoColumnId, CT.SYS_CHANGE_COLUMNS) =1
THEN ThumbNailPhoto
ELSE NULL
END AS CT_ThumbNailPhoto,
CHANGE_TRACKING_IS_COLUMN_IN_MASK(
@PhotoColumnId, CT.SYS_CHANGE_COLUMNS) AS
CT_ThumbNailPhoto_Changed
CT.SYS_CHANGE_OPERATION, CT.SYS_CHANGE_COLUMNS,
CT.SYS_CHANGE_CONTEXT
FROM
SalesLT.Product AS P
INNER JOIN
CHANGETABLE(CHANGES SalesLT.Product,
@last_synchronization_version) AS CT
ON
P.ProductID = CT.ProductID AND
CT.SYS_CHANGE_OPERATION ='U'
获得一致且正确的结果
若要获取更改的表数据，您需要执行多个步骤。请注意，如果没有考虑到并处理某些问题，可能会返回不一致或错误的结果。
例如，若要获取对 Sales 和 SalesOrders 表所做的更改，应用程序应执行以下步骤：
1.使用CHANGE_TRACKING_MIN_V ALID_VERSION() 验证上次同步版本。
2.使用CHANGE_TRACKING_CURRENT_VERSION() 获取可供下次获取更改时使
用的版本。
3.使用CHANGETABLE(CHANGES …) 获取对Sales 表所做的更改。
4.使用CHANGETA BLE(CHANGES …) 获取对SalesOrders 表所做的更改。
数据库中运行的两个进程可能会影响上述步骤返回的结果：
?清除进程在后台运行，并删除早于指定保持期的更改跟踪信息。
清除进程是一个单独的后台进程，它使用在为数据库配置更改跟踪时指定的保持
期。问题是清除进程可能会在验证上次同步版本之后以及调用
CHANGETABLE(CHANGES…) 之前运行。到获取更改时，刚刚还有效的上次同步版本可能不再有效。因此，可能会返回错误的结果。
?正在Sales 和SalesOrders 表中执行DML 操作，如下面的操作：
o在使用CHANGE_TRACKING_CURRENT_VERSION() 获取下次使用的版本后，可能对表进行了更改。因此，返回的更改可能超过预期数量。
o可能在从Sales 表中获取更改的调用以及从SalesOrders 表中获取更改的调用之间提交了事务。因此，SalesOrder 表的结果可能包含Sales 表中不存
在的外键值。
若要解决上面列出的难题，建议您使用快照隔离。这有助于确保更改信息的一致性，并避免出现与后台清除任务有关的争用情况。如果没有使用快照事务，在开发使用更改跟踪的应用程序时，可能需要增加很多工作量。
使用快照隔离
从设计上，更改跟踪可以很好地与快照隔离配合使用。必须为数据库启用快照隔离。获取更改所需的所有步骤必须包含在快照事务中。这可确保快照事务中的查询看不见在获取更改时对数据所做的所有更改。
若要获取快照事务中的数据，请执行以下步骤：
1.将事务隔离级别设置为快照，然后启动一个事务。
2.使用CHANGE_TRACKING_MIN_V ALID_VERSION() 验证上次同步版本。
3.使用CHANGE_TRACKING_CURRENT_VERSION() 获取下次使用的版本。
4.使用CHANGETABLE(CHANGES …) 获取对Sales 表所做的更改。
5.使用CHANGETABLE(CHANGES …) 获取对SalesOrders 表所做的更改。
6.提交事务。
由于获取更改所需的所有步骤都是在快照事务中执行的，因此，应注意以下事项：
?如果清除是在验证上次同步版本之后进行的，则来自
CHANGETABLE(CHANGES …) 的结果仍然有效，因为在事务中看不见清除执行的删除操作。
?在获取下次同步版本后对Sales 或SalesOrders 表所做的所有更改将不可见，并且CHANGETABLE(CHANGES …) 调用绝不会返回版本晚于
CHANGE_TRACKING_CURRENT_VERSION() 返回结果的更改。还会保持Sales
和SalesOrders 表之间的一致性，因为在CHANGETABLE(CHANGES …) 调用之
间提交的事务将不可见。
下面的示例说明了如何为数据库启用快照隔离。
-- The database must be configured to enable snapshot isolation. ALTER DATABASE AdventureWorksLT2008
SET ALLOW_SNAPSHOT_ISOLATION ON;
快照事务是按如下方式使用的：
SET TRANSACTION ISOLATION LEVEL SNAPSHOT;
BEGIN TRAN
-- Verify that version of the previous synchronization is valid. -- Obtain the version to use next time.
-- Obtain changes.
COMMIT TRAN
有关快照事务的详细信息，请参阅使用基于行版本控制的隔离级别。
使用快照隔离的替代方法
使用快照隔离有一些替代方法，但它们需要完成更多的工作以确保满足所有应用程序要求。若要确保last_synchronization_version有效，并且清除进程在获取更改之前没有删除数据，请执行以下操作：
1.在调用CHANGETABLE() 后检查last_synchronization_version。
2.在使用CHANGETABLE() 获取更改的每个查询中检查
last_synchronization_version。
在为下次枚举获取同步版本后，可能会发生数据更改。可以使用两种方法来处理这种情况。所使用的选项取决于应用程序及其处理每种方法的副作用的方式：
?忽略版本高于新同步版本的更改。
这种方法具有以下副作用：如果创建或更新的行版本早于新同步版本，将跳过新行或更新的行，但以后会对其进行更新。如果有一个新行，并且另一个表中创建的行引用跳过的行，则可能会出现引用完整性问题。如果更新了某个现有行，将跳过该行，并且下次才会对其进行同步。
?包括所有更改，即便更改的版本高于新同步版本。
下次进行同步时，将重新获取版本高于新同步版本的行。应用程序必须能够预料并处理这种情况。
除了上述两个选项外，还可以设计结合这两个选项的方法，具体取决于所执行的操作。例如，您可能希望应用程序最好忽略晚于下次同步版本（在该版本中创建或删除了行）的更改，但不忽略更新。
https://www.360docs.net/doc/2611078698.html,/tuyile006/archive/2010/04/01/1702218.html
---------------------------------------------------------------------
操作系统死锁练习及答案
死锁练习题 (一)单项选择题 l系统出现死锁的根本原因是( )。A．作业调度不当B．系统中进程太多C．资源的独占性D．资源管理和进程推进顺序都不得当 2．死锁的防止是根据( )采取措施实现的。A．配置足够的系统资源B．使进程的推进顺序合理C．破坏产生死锁的四个必要条件之一D．防止系统进入不安全状态 3．采用按序分配资源的策略可以防止死锁．这是利用了使( )条件不成立。A．互斥使用资源B循环等待资源c．不可抢夺资源D．占有并等待资源 4．可抢夺的资源分配策略可预防死锁，但它只适用于( )。A．打印机B．磁带机c．绘图仪D．主存空间和处理器 5．进程调度算法中的( )属于抢夺式的分配处理器的策略。A．时间片轮转算法B．非抢占式优先数算法c．先来先服务算法D．分级调度算法 6．用银行家算法避免死锁时，检测到( )时才分配资源。A．进程首次申请资源时对资源的最大需求量超过系统现存的资源量B．进程己占用的资源数与本次申请资源数之和超过对资源的最大需求量c．进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足尚需的最大资源量D进程已占用的资源数与本次申请的资源数 之和不超过对资源的最大需求量，且现存资源能满足本次申请量，但不能满足尚需的最大资源量 7．实际的操作系统要兼顾资源的使用效率和安全可靠，对资源的分配策略，往往采用( )策略。A死锁的防止B．死锁的避免c．死锁的检测D．死锁的防止、避免和检测的混合(二)填空题 l若系统中存在一种进程，它们中的每一个进程都占有了某种资源而又都在等待其中另一个进程所占用的资源。这种等待永远不能结束,则说明出现了______。2．如果操作系统对 ______或没有顾及进程______可能出现的情况，则就可能形成死锁。3．系统出现死锁的四
6个哲学家进餐问题预防死锁
红河学院 课程设计报告 操作系统 课程名称： 6个哲学家进餐 设计题目： 院系：工学院 专业：计算机科学与技术班级：11计科班 曹永前 设计者： 学号：201101030466 指导教师：韦相 2013 年 5 月26 日
1. 问题描述： 一个房间内有6个哲学家，他们的生活就是思考和进食。哲学家思考后，过一定的时间就会饥饿，饥饿之后就想吃饭，吃饭后再思考。房间里有一张圆桌，桌子周围放有五把椅子，分别属于五位哲学家每两位哲学家之间有一把叉子，哲学家进食时必须同时使用左右两把叉子。 2. 问题分析 1、写出哲学家进餐的算法描述。 用六只筷子解决需要用两双筷子来进餐的六个哲学家,由于每个哲学家都需要其周围的两只筷子,所以筷子是公用信号量,这久需要设置一个互斥信号量,来使六个哲学家互斥的进餐.具体做法将六个信号量设置为0-5,用pv 源于来控制信号量,并将六个哲学家分别编号为0-5.经过仔细分析我们会发现,有这样一个问题存在,就是当每个哲学家都申请到他周围的一只筷子时,由于他们每人都只有一只筷子无法进餐,没有进餐他们就无法释放他们已经得得到的筷子,这样是进餐出于一种僵局,无法继续下去,这就是死锁问题. 2、死锁问题的分析与具体的解决方法。 死锁问题就是当每个哲学家都拿到且只拿到一只筷子, 这样每个哲学家都无
法进餐,也无法释放所得到的筷子,所以解决死锁我们就要从这入手,就是怎样去预防使所有哲学家不要同时去申请他们同一方向的筷子.根据这解决死锁的方法有以下几种: a.每一次最多只能有五个哲学家申请进餐.这样其中的一个哲学家就能申请 到两只筷子,就能够进餐,再将筷子释放给其他哲学家进餐. b.用AND信号量,就是哲学家需同时申请其左右两边的筷子,两边都有资源的 时候,才能让这个哲学家得到资源,这样哲学家只要申请到筷子就能进餐, 再将筷子释放给其他哲学家进餐. c.用管程机制来实现。 d.我们前面已经将每个哲学家都分配了一个编号,我们可以编号为奇数的哲 学家首先去申请其左边的筷子,再去申请其右手边的筷子;让编号为偶数的哲学家,先去申请其右边的筷子,再去申请其左边的筷子.我们可以看出编号为奇数的哲学家左边,与编号为偶数的哲学家的右边为同一只筷子,当其中一个哲学家拿到此筷子后,他另一边的筷子也是空闲的,这样就能避免死锁. 主程序中我使用的是最后一种避免死锁的方法. 3、用C程序实现哲学家进餐。（注：可以使用共享变量的方式，也可以使用信 号量的方式或其他方法来实现） 3.程序清单 #include 第三章处理机调度与死锁 一、单项选择题 1、操作系统中的作业管理是一种（A ）。 A.宏观的高级管理 B.宏观的低级管理 C.系统刚开始加电 D.初始化引导完成 2、作业调度又称为[1A]，它决定将哪些在外存储器上的处于[2D]状态的作业调入主机内存。 系统经作业调度程序选中一个或多个作业后，就为它们分配必要的内存、设备及软资源。然后控制权就交给了[3B]，由[3]将它们变为一个或一组[4C]，并[5A]。 供选择的答案： [1]：A、高级调度B、低级调度C、中级调度 D、进程调度 [2]：A、就绪B、阻塞C、提交D、后备 [3]：A、存储管理模块B、处理机管理模块C、文件管理模块D、设备管理模块 [4]：A、指令B、子程序C、进程D、程序段 [5]：A、把它们挂到就绪队列上B、为它们分配处理机 C、把它们挂到后备队列上 D、为它们分配设备 3、处于后备状态的作业存放在（A ）中。 A.外存 B.内存 C.A和B D.扩展内存 4、在操作系统中，JCB是指（A ）。 A.作业控制块 B.进程控制块 C.文件控制块 D.程序控制块 5、作业在系统中存在与否的唯一标志是（C）。 A.源程序 B.作业说明书 C.作业控制块 D.目的程序 6、按照作业到达的先后次序调度作业，排队等待时间最长的作业被优先调度，这是指（A）调度算法。 A.先来先服务法 B. 短作业优先法 C.时间片轮转法 D. 优先级法 7、在批处理系统中，周转时间是（B ）。 A.作业运行时间 B.作业等待时间和运行时间之和 C.作业的相对等待时间 D.作业被调度进入内存到运行完毕的时间 8、为了对紧急进程或重要进程进行调度，调度算法应采用（B）。 A.先来先服务法 B. 优先级法 C.短作业优先法 D. 时间片轮转法 9、操作系统中，（A）负责对进程进行调度。 A.处理机管理 B. 作业管理 C.高级调度管理 D. 存储和设备管理 第6章死锁-习题集 一、选择题 1. C 2. C 3. C 4. C //产生死锁的原因是系统资源不足及进程推进顺序不正确 5. B 6. D 7. B 8. C 9. C 10. D //有序资源分配法的实现思想是将系统中的所有资源都按类型赋予一个编号（如打 印机1，磁带机为2等），要求每一个进程均严格按照编号递增的次序来申请资源，同类资源一次申请完。这样不会造成循环等待。 11. A //互斥条件是资源本身固有的特性。 12. B //当每个都获得2台打印机且系统中剩余打印机不少于1台时，系统不会发生死锁， 即11-2N>=1，由此知N<=5。 //本注： N=1，空闲11-3*1=8，不死锁 N=2，空闲11-3*2=5，不死锁 N=3，空闲11-3*3=2，不死锁 N=4，每个2台，空闲11-2*4=3，不死锁 N=5，每个2台，空闲11-2*5=1，不死锁 N=6，5个进程2台，1个进程1台，无空闲，死锁！ 13. C //同上例。8-2K>=1，K<=3.5，向上取整为4。 14. B 15. B 16. B //本注：破坏了死锁必要条件“环循等待”，属于“死锁预防” 17. C 18. D //本注：P2和P3无法满足资源需要，都需资源R2三个。 二、综合应用题 1.所谓死锁是指多个进程因竞争系统资源或相互通信而处于永久阻塞状态，若无外力作 用，这些进程都将无法向前推进。 产生死锁的原因是：一是由多进程共享的资源不足而引起竞争资源；二是由于进程在运行过程中具有异步性，进程推进顺序非法。 2.必要条件如下： ●互斥条件。指在一段时间内某资源仅为一个进程所占有。 ●不剥夺条件。指进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走， 而只能由该进程自己释放。 ●部分已分配条件(Hold and Wait)：指进程每次申请它所需要的一部分资源，在等待 分配新资源的同时，进程继续占有已分配到的资源。 ●环路等待条件。指存在一种进程资源的循环等待链，链中每一个进程已获得的资源 同时被链中下一个进程所请求。 解决死锁问题常采用的措施有： ●死锁预防。通过破坏死锁产生的四个必要条件中之一来预防死锁的发生。 ●死锁避免。在资源动态分配进程中，用某种方法防止系统进程不安全状态，从而避 免死锁。 ●死锁的检测及解除。通过系统的检测机构及时地检测出死锁的发生，然后采取某种 措施解除死锁。 3.有可能。例如在系统死锁的状态下，进程处于占有等待资源的状态，应当即不属于运行 态也不属于就绪态，即都处于阻塞状态时。 4.在资源分配系统中，死锁发生的原因是由于多个进程共享有限的独占型资源。当多个进 程占有了部分资源又需要更多的资源时，就可能形成循环等待链而导致死锁。 死锁情况分析：每个进程都占有W-1个资源，需再分配1个资源，为保证不死锁，系统必须至少有一个可分配的资源，取M满足： M>=N(W-1)+1 因此保证系统不发生死锁的最小M什可以从下面公式获得： M=N(W-1)+1 1)2*0+1=1，而M=3，不会死锁 2)2*1+1=3，而M=3，不会死锁 3)2*2+1=5，而M=3，可能死锁。出现死锁情况是：一个进程占有2个资源，另一占 1个资源 4)3*1+1=4，而M=5，不会死锁 5)3*2+1=7，而M=7，可能死锁。出现死锁情况是：3个进程各占2个资源 SQLServer和Oracle是大家经常用到的数据库，在此总结出这些常用函数以供大家参考。 数学函数 1.绝对值 S:select abs(-1) value O:select abs(-1) value from dual 2.取整(大) S:select ceiling(-1.001) value O:select ceil(-1.001) value from dual 3.取整（小） S:select floor(-1.001) value O:select floor(-1.001) value from dual 4.取整（截取） S:select cast(-1.002 as int) value O:select trunc(-1.002) value from dual 5.四舍五入 S:select round(1.23456,4) value 1.23460 O:select round(1.23456,4) value from dual 1.2346 6.e为底的幂 S:select Exp(1) value 2.7182818284590451 O:select Exp(1) value from dual 2.71828182 7.取e为底的对数 S:select log(2.7182818284590451) value 1 O:select ln(2.7182818284590451) value from dual; 1 8.取10为底对数 S:select log10(10) value 1 O:select log(10,10) value from dual; 1 9.取平方 S:select SQUARE(4) value 16 O:select power(4,2) value from dual 16 10.取平方根 S:select SQRT(4) value 2 O:select SQRT(4) value from dual 2 11.求任意数为底的幂 第五章死锁练习题 (一)单项选择题 1．系统出现死锁的根本原因是( )。 A．作业调度不当B．系统中进程太多C．资源的独占性D．资源管理和进程推进顺序都不得当 2．死锁的防止是根据( )采取措施实现的。 A．配置足够的系统资源B．使进程的推进顺序合理 C．破坏产生死锁的四个必要条件之一D．防止系统进入不安全状态 3．采用按序分配资源的策略可以防止死锁．这是利用了使( )条件不成立。 A．互斥使用资源B循环等待资源C．不可抢夺资源D．占有并等待资源 4．可抢夺的资源分配策略可预防死锁，但它只适用于( )。 A．打印机B．磁带机C．绘图仪D．主存空间和处理器 5．进程调度算法中的( )属于抢夺式的分配处理器的策略。 A．时间片轮转算法B．非抢占式优先数算法C．先来先服务算法D．分级调度算法 6．用银行家算法避免死锁时，检测到( )时才分配资源。 A．进程首次申请资源时对资源的最大需求量超过系统现存的资源量 B．进程己占用的资源数与本次申请资源数之和超过对资源的最大需求量 C．进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足尚需的最大资源量 D进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足本次申请量，但不能满足尚需的最大资源量 7．实际的操作系统要兼顾资源的使用效率和安全可靠，对资源的分配策略，往往采用( )策略。 A死锁的防止B．死锁的避免C．死锁的检测D．死锁的防止、避免和检测的混合 (二)填空题 1．若系统中存在一种进程，它们中的每一个进程都占有了某种资源而又都在等待其中另一个进程所占用的资源。这种等待永远不能结束,则说明出现了______。 2．如果操作系统对______或没有顾及进程______可能出现的情况，则就可能形成死锁。 3．系统出现死锁的四个必要条件是：互斥使用资源，______，不可抢夺资源和______。 4．如果进程申请一个某类资源时，可以把该类资源中的任意一个空闲资源分配给进程，则说该类资源中的所有资源是______。 5．如果资源分配图中无环路，则系统中______发生。 6．为了防止死锁的发生，只要采用分配策略使四个必要条件中的______。 7．使占有并等待资源的条件不成立而防止死锁常用两种方法：______和______. 8静态分配资源也称______，要求每—个进程在______就申请它需要的全部资源。 9．释放已占资源的分配策略是仅当进程______时才允许它去申请资源。 10．抢夺式分配资源约定，如果一个进程已经占有了某些资源又要申请新资源，而新资源不能满足必须等待时、系统可以______该进程已占有的资源。 11．目前抢夺式的分配策略只适用于______和______。 12．对资源采用______的策略可以使循环等待资源的条件不成立。 13．如果操作系统能保证所有的进程在有限的时间内得到需要的全部资源，则称系统处于______。14．只要能保持系统处于安全状态就可______的发生。 15．______是一种古典的安全状态测试方法。 16．要实现______，只要当进程提出资源申请时，系统动态测试资源分配情况，仅当能确保系统安全时才把资源分配给进程。 死锁习题 一、填空题 2．死锁产生的原因是。 3．产生死锁的四个必要条件是、、、。 二、单项选择题 1．两个进程争夺同一个资源。 （A）一定死锁（B）不一定死锁 （C）不死锁（D）以上说法都不对 4．如果发现系统有的进程队 列就说明系统有可能发生死锁了。 （A）互斥（B）可剥夺 （C）循环等待（D）同步 5．预先静态分配法是通过破坏条件，来达到预防死锁目的的。 （A）互斥使用资源/循环等待资源 （B）非抢占式分配/互斥使用资源 （C) 占有且等待资源/循环等待资源 （D）循环等待资源/互斥使用资源 7．下列关于死锁的说法中，正确的是？ 1）有环必死锁; 2）死锁必有环; 3）有环无死锁; 4）死锁也无环 8．资源有序分配法的目的是？ 1）死锁预防; 2）死锁避免; 3）死锁检测; 4）死锁解除 8．死锁的预防方法中，不太可能的一种方法使（）。 A 摈弃互斥条件 B 摈弃请求和保持条件 C 摈弃不剥夺条件 D 摈弃环路等待条件 10. 资源的按序分配策略可以破坏（）条件。 A 互斥使用资源 B 占有且等待资源 C 不可剥夺资源 D 环路等待资源 三、多项选择题 1．造成死锁的原因是_________。 （A）内存容量太小（B）系统进程数量太多，系统资源分配不当 （C）CPU速度太慢（D）进程推进顺序不合适 （E）外存容量太小 2．下列叙述正确的是_________。 （A）对临界资源应采取互斥访问方式来实现共享 （B）进程的并发执行会破坏程序的“封 闭性” （C）进程的并发执行会破坏程序的“可再现性” （D）进程的并发执行就是多个进程同时占有CPU （E）系统死锁就是程序处于死循环3．通常不采用_________方法来解除死锁。 （A）终止一个死锁进程（B）终止所有死锁进程 （C）从死锁进程处抢夺资源（D）从非死锁进程处抢夺资源 （E）终止系统所有进程 5．通常使用的死锁防止策略有_________。 （A）动态分配资源（B）静态分配资源 （C）按序分配资源（D）非剥夺式分配资源 （E）剥夺式分配资源 四、名词解释 1死锁 第五章死锁 一．选择题 1.为多道程序提供的可共享资源不足时，可能出现死锁。但是，不适当的 C 也可能产生死锁。 （A）进程优先权（B）资源的线性分配 （C）进程推进顺序（D）分配队列优先权 2.采用资源剥夺法可以解除死锁，还可以采用 B 方法解除死锁。 （A）执行并行操作（B）撤销进程 （C）拒绝分配新资源（D）修改信号量 3.产生死锁的四个必要条件是：互斥、 B 循环等待和不剥夺。 （A）请求与阻塞（B）请求与保持 （C）请求与释放（D）释放与阻塞 4.在分时操作系统中，进程调度经常采用算法。 （A）先来先服务（B）最高优先权 （C）时间片轮转（D）随机 5.资源的按序分配策略可以破坏条件。 （A）互斥使用资源（B）占有且等待资源 （C）非抢夺资源（D）循环等待资源 6.在 C 情况下，系统出现死锁。 （A）计算机系统发生了重大故障 （B）有多个封锁的进程同时存在 （C）若干进程因竞争而无休止地相互等待他方释放已占有的资源 （D）资源数远远小于进程数或进程同时申请的资源数量远远超过资源总数 7。银行家算法在解决死锁问题中是用于 B 的。 （A）预防死锁（B）避免死锁 （C）检测死锁（D）解除死锁 8.支持多道程序设计的操作系统在运行过程中，不断地选择新进程运行来实现CPU的共享，但其中不是引起操作系统选择新进程的直接原因。 （A）运行进程的时间片用完 （B）运行进程出错 （C）运行进程要等待某一事件发生 （D）有新进程进入就绪队列 9. 在下列解决死锁的方法中，属于死锁预防策略的是 B 。 （A）银行家算法 （B）有序资源分配法 （C）死锁检测法 （D）资源分配图化简法 二、综合题 1.若系统运行中出现如表所示的资源分配情况，改系统是否安全？如果进程P2此时提出资源申请（1，2，2，2），系统能否将资源分配给它？为什么？ 1.避免死锁的方法有哪些?答案：有一种最简单的就是：全部程序禁用，然后重启自己需要 的程序。用行级锁，不去征用大表的主键，用小事务。 2.在Sybase数据库中注册用户与数据库用户有什么区别? 答案：Sybase中没有注册用户数这个说法，如果是LICENSE中的，技术上可以忽略，用户 数EE版可以设很大，几万，SMB版可以设256个。 3.在MS SQL_Server 数据库中通过什么约束保证数据库的实体完整性 答案：可以通过建立唯一的索引、PRIMARY KEY约束、UNIQUE约束或IDENTITY约束来实现 实体完整性 4.内存有哪几种存储组织结构.请分别加以说明 中的Wait() 和notify()方法使用时应注意些什么? 答案：Wait()和notify():如果条件不满足，则等待。当条件满足时，等待该条件的线程将 被唤醒。一般用在synchronized机制中例如:线程Asynchronized(obj) {while(!condition) {();}();} 当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于 是线程A就wait（）。在另一线程B中，如果B更改了某些条件，使得线程A的condition 条件满足了，就可以唤醒线程A：线程Bsynchronized(obj) {condition = true;();}需要 注意的概念是：◆调用obj的wait（）， notify（）方法前，必须获得obj锁，也就是 必须写在synchronized（obj）{……} 代码段内。◆调用（）后，线程A就释放了obj 的锁，否则线程B无法获得obj锁，也就无法在synchronized（obj）{……} 代码段内唤 醒A. ◆当（）方法返回后，线程A需要再次获得obj锁，才能继续执行。◆如果A1， A2，A3都在（），则B调用（）只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。 ◆（）则能全部唤醒A1，A2，A3，但是要继续执行（）的下一条语句，必须获得obj锁， 因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj 锁之后才能继续执行。◆当B调用notifyAll的时候，B正持有obj锁，因此，A1，A2， A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1， A2，A3中的一个才有机会获得锁继续执行。 6.用户输入一个整数.系统判断,并输出是负数还是非负数,请设计测试用例. 7.操作系统中的同步和互诉解决了什么问题 答案：同步：各个进程不知对方名字，但通过某些对象（如I/O缓冲区）的共同存取来协同 完成一项任务。互斥：互斥跟临界资源有关，因为计算机的某些资源有限，所以必须通过互 斥操作防止进程之间竞争临界资源而发生死锁，互斥操作用PV原语实现。 8.UNIX 中init 1.不许用中间变量,把String ABCDE 倒转 public class StringDemo { public static void main(String[]args) { String str="ABCD"; for (int i = ()-1; i >=0; i--) { str+=(i)); } str=("ABCD".length(), ()); }} 个数求第2大的数,不许用排序算法 3.排序算法的测试用例 1, 合并有序链表 2, 删除字符串中相邻重复元素 3, 给出了二叉树结构，要求写出广度优先遍历 4, 给定整型数组，写代码找出数组中第二大元素 5, 有关菲波那契数列问题 1.怎么判断鼠标有没有选中一条线段（如很靠近，鼠标点和线段之间的距离小于5毫米） 2.求一个矩形的中心点和一个点的连线与矩形边的交点坐标（矩形左上角坐标给出，长、宽 SQL Server和MySql语法和关键字的区别 ——用于SQLServer到MySql的转换 对于程序开发人员而言，目前使用最流行的两种后台数据库即为MySQL and SQL Server。这两者最基本的相似之处在于数据存储和属于查询系统。你可以使用SQL来访问这两种数据库的数据，因为它们都支持ANSI-SQL。还有，这两种数据库系统都支持二进制关键词和关键索引，这就大大地加快了查询速度。同时，二者也都提供支持XML的各种格式。除了在显而易见的软件价格上的区别之外，这两个产品还有什么明显的区别吗？在这二者之间你是如何选择的？让我们看看这两个产品的主要的不同之处，包括发行费用，性能以及它们的安全性。 ◆根本的区别是它们遵循的基本原则 二者所遵循的基本原则是它们的主要区别：开放vs保守。SQL服务器的狭隘的，保守的存储引擎与MySQL服务器的可扩展，开放的存储引擎绝然不同。虽然你可以使用SQL服务器的Sybase引擎，但MySQL能够提供更多种的选择，如MyISAM,Heap,InnoDB,and Berkeley DB。MySQL不完全支持陌生的关键词，所以它比SQL服务器要少一些相关的数据库。同时，MySQL也缺乏一些存储程序的功能，比如MyISAM引擎联支持交换功能。 ◆发行费用：MySQL不全是免费，但很便宜 当提及发行的费用，这两个产品采用两种绝然不同的决策。对于SQL服务器，获取一个免费的开发费用最常的方式是购买微软的Office或者Visual Studio的费用。但是，如果你想用于商业产品的开发，你必须还要购买SQL Server Standard Edition。学校或非赢利的企业可以不考虑这一附加的费用。 ◆性能：先进的MySQL 纯粹就性能而言，MySQL是相当出色的，因为它包含一个缺省桌面格式 MyISAM。MyISAM数据库与磁盘非常地兼容而不占用过多的CPU和内存。 MySQL可以运行于Windows系统而不会发生冲突，在UNIX或类似UNIX 系统上运行则更好。你还可以通过使用64位处理器来获取额外的一些性能。 因为MySQL在内部里很多时候都使用64位的整数处理。Yahoo!商业网站就使用MySQL作为后台数据库。 当提及软件的性能，SQL服务器的稳定性要比它的竞争对手强很多。但是，这些特性也要付出代价的。比如，必须增加额外复杂操作，磁盘存储，内存损耗等等。如果你的硬件和软件不能充分支持SQL服务器，我建议你最好选择其他如DBMS数据库，因为这样你会得到更好的结果。 ◆安全功能 第五章死锁练习题参考答案 (一)单项选择题 1．D 2．C 3．B 4．D 5．A 6．C 7．D (二)填空题 1．死锁2．资源管理不得当，并发执行时3．占有并等待资源，循环等待资源4．等价的5．没有死锁6．一个条件不成立7．静态分配资源，释放已占资源8．预分配资源．开始执行前9．没有占用资源10．抢夺11．主存空间，处理器12．按序分配13安全状态14．避免死锁15．银行家算法16．死锁的避免17．n(x- 1)+l<=m 18．死锁检测方法19判断系统，解除死锁20．占用表，等待表21．尚需量，剩余量22终止，抢夺资源23．校验点24．防止，检测 (三)简答题 1．若系统中存在一组进程、它们中的每—个进程都占用了某种资源而又都在等待其中另一个进程所占的资源，这种等待永远不能结束，则说明系统出现了死锁。产生死锁的原因有两个:一是操作系统对资源的管理不当，二是没有顾及进程并发执行时可能出现的情况。 2．采用某些资源分配策略使死锁的四个必要条件之一不成立，就能防止死锁。除第一个条件互斥使用资源没有对应策略外，对占有并等待资源、不可抢夺资源和循环等待资源这三个条件可采用静态分配资源，释放已占资源，抢夺式分配资源和按序分配资源等资源分配策略。 3．如果操作系统能保证所有的进程在有限的时间内得到需要的全部资源，则称系统处于安全状态。常用银行家算法动态地检测系统中的资源分配情况和进程对资源的需求情况进行资源分配，确保系统处于安全状态。 4解决死锁问题有以下三种方法：(1)死锁的防止。系统按预定的策略为进程分配资源，这些分配策略能使死锁的四个必要条件之一不成立，从而使系统不产生死锁。(2)死锁的避免。系统动态地测试资源分配情况，仅当能确保系统安全时才给进程分配资源。(3)死锁的检测。对资源的申请和分配不加限制，只要有剩余的资源就可把资源分配给申请者，操作系统要定时判断系统是否出现了死锁，当有死锁发生时设法解除死锁。5．用抢夺资源的方式解除死锁时要注意三点：(1)抢夺进程资源时希望付出的代价最小。(2)为被抢夺者的恢复准备好条件，如返回某个安全状态，并记录有关信息。(3)防止被抢夺资源的进程“饿死”,一般总是从执行时间短的进程中抢夺资源。 (四)应用题 1．(1)根据表，P1，P2和P3三个进程尚需资源数分别是4，5和1，系统的资源剩余量为2，若把剩余的资源量全部分配给P2，系统产已无资源可分配，使三个进程都等待资源而无法完成，形成死锁。所以不能先满足进程P2的要求。 (2)可先为进程P3分配1个资源，当它归还3个资源后，这样共有4个可分配资源，可满足P1申请1个资源的要求，再分配3个资源给进程P1，待P1归还7个资源后，先满足P2申请2个资源的请求，分配给进程P2，再分配3个资源给P2，使它完成。 2．(1)系统目前尚余有的资源数为(2，6，2，1)，五个进程尚需的资源数分别是A：(2，0，0，0) ; B：(0，0，0,0); C：(4，6，2，0) ; D：(5，7，0，0); E：(0,0，2，1);由于进程B己满足了全部资源需求，它在有限时间内会归还这些资源，因此可分配资源达到(3，6，4，1)，这样就可分配给进程A；等A归还资源后，可分配资源达到(6，12，6，1)，再分配给进程C；之后可分配资源会达到(7，12，10，1)，分配给进程D并等待一段时间后，可分配资源将达到(7，12，10，2)，最后，可分配给进程E，满足其全部请求。所以说目前系统处于安全状态。 (2)若此时给进程D分配(2，5，0，0)个资源，进程D尚需(3，2，0，0)，则系统剩余的资源量为(0， 1.有三个批处理作业，第一个作业10:00 到达，需要执行2 小时；第二个作业在10:10 到达，需要执行1 小时；第三个作业在10:25 到达，需要执行25 分钟。分别采用先来先服务，短作业优先和最高响应比优先三种调度算法，各自的平均周转时间是多少？ 解： 先来先服务： （结束时间=上一个作业的结束时间+执行时间 周转时间=结束时间-到达时间=等待时间+执行时间） 短作业优先： 1)初始只有作业1，所以先执行作业1，结束时间是12:00，此时有作业2和3； 2)作业3需要时间短，所以先执行； 最高响应比优先： 高响应比优先调度算法既考虑作业的执行时间也考虑作业的等待时间，综合了先来先服务和最短作业优先两种算法的特点。 1)10:00只有作业1到达，所以先执行作业1； 2)12:00时有作业2和3， 作业2：等待时间=12:00-10:10=110m;响应比=1+110/60=2.8； 作业3：等待时间=12:00-10:25=95m，响应比=1+95/25=4.8； 所以先执行作业3 2.在一单道批处理系统中，一组作业的提交时刻和运行时间如下表所示。试计算一下三种作业调度算法的平均周转时间T 和平均带权周转时间W。 （1）先来先服务；（2）短作业优先（3）高响应比优先 解： 先来先服务： 短作业优先： 作业顺序： 1)8:00只有作业1，所以执行作业1； 2)9:00有作业2和3，作业3短，所以先执行3； 3)9:12有作业2和4，作业4短，所以先执行4； 高响应比优先： 作业顺序： 1)8:00只有作业1，所以执行作业1； 2)9:00有作业2和3 作业2等待时间=9:00-8:30=30m，响应比=1+30/30=2； 作业3等待时间=9:00-9:00=0m，响应比=1+0/12=1； 所以执行作业2； 3)9:30有作业3和4 作业3等待时间=9:30-9:00=30m，响应比=1+30/12=3.5； 作业4等待时间=9:30-9:06=24m，响应比=1+24/6=5； 死锁的预防与避免 一．死锁 操作系统中的死锁被定义为系统中两个或者多个进程无限期地等待永远不会发生的条件，系统处于停滞状态，这就是死锁。产生死锁的原因主要是：1.系统资源不足， 2.进程运行推进的顺序不合适， 3.资源分配不当 如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。 产生死锁的四个必要条件：1）互斥条件：一个资源每次只能被一个进程使用。 （2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 （3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。 （4）环路等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。 这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。 二．预防死锁： 该方法是通过设置某些限制条件，去破坏产生死锁的四个必要条 件的一个或多个条件，来预防发生死锁。易实现，被广泛使用，但由于所施加的限制条件往往太严格，因而可能导致系统资源利用率和吞吐量降低。 三．避免死锁 避免死锁是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免死锁，而不需事先采取各种限制措施去破坏产生死锁的四个必要条件。这种方法施加的限制条件较弱，但在实现上有一定的难度。 四．区别 死锁避免和死锁预防的区别在于,死锁预防是设法至少破坏产生死锁的四个必要条件之一,严格的防止死锁的出现,而死锁避免则不那么严格的限制产生死锁的必要条件的存在,因为即使死锁的必要条件存在,也不一定发生死锁.死锁避免是在系统运行过程中注意避免死锁的最终发生. 2010年第12期吉林省教育学院学报 N o .12,2010 第26卷J O U R N A LO FE D U C A T I O N A LI N S T I T U T EO FJ I L I NP R O V I N C E V o l .26(总240期) T o t a l N o .240 收稿日期:2010—07—25作者简介:哈森格日乐,女,内蒙古兴安盟广播电视大学,讲师。研究方向:计算机应用。 操作系统中死锁与死机现象的教学比较 哈森格日乐 (内蒙古兴安盟广播电视大学,内蒙古兴安盟137400) 摘要:死锁是计算机操作系统中的一个突出问题。死锁与死机是两个不同又有关联的概念。本文从死锁与死机的概念、 产生的原因及排除三个方面进行了比较论述。 关键词:死锁;死机;进程中图分类号:G 642.0 文献标识码:A 文章编号:1671—1580(2010)12—0071—02 操作系统中的死锁可定义为:各并发进程彼此互相等待对方所拥有的资源,且这些并发进程在得到对方的资源之前不会释放自己所拥有的资源。从而造成大家都想得到资源而又都得不到资源,各并发进程不能继续向前推进的状态。它是操作系统核心在内部管理和控制的调度设计中造成系统无法继续运行的“死机”现象。 一、产生死锁与“死机”的原因(一)死锁的起因及必要条件 死锁的起因是并发进程的资源竞争。产生死锁的根本原因在于系统提供的资源个数少于并发进程所要求的该类资源数。显然,由于资源的有限性,不可能为所有要求资源的进程无限制地提供资源。但是,可以采用适当的资源分配算法,以达到消除死锁的目的。然而要达到消除死锁的目的必须了解产生死锁的必要条件。这个我们从死锁的概念就可以得到。1.互斥条件。并发进程所要求和占有的资源是不能同时被两个以上进程使用或操作的,进程对它所需要的资源进行排他性控制;2.不剥夺条件。进程所获得的资源在未使用完毕之前,不能被其他进程强行剥夺,而只能由获得该资源的进程自己释放;3.部分分配。进程每次申请它所需要的一部分资源,在等待新资源的同时,继续占用已分配到的资源;4.环路条件。存在一种进程循环链,链中每一个进程已获得的资源同时被下一个进程所请求。 (二)“死机”的原因1.W i n d o w s 的即插即用功能,简化了新硬件的安装,但随之而来的是系统启动时,总是要搜索所有的驱动程序再决定运行。因此,某些失效硬件的驱动程序会导致“死机”。 2.资源耗尽:“蓝屏”故障常常发生在进行一项比较大或比较多的工作时,或是在保存复制的时候,往往发生得比较突然。这类故障的发生原因主要是与三个堆资源(系统资源、用户资源、G D I 资源)的占用情况有关。资源耗尽会出现“系统资源严重不足”等“蓝屏”警告。平时可以观察一下系统资源的可用比例。 3.版本冲突:尤其是不同文件管理方式。W i n 98与W i n 2000等的F A T 16/32、N T F S 就是如此。 4.注册表损坏:注册表是W i n d o w s 95之后引入的一个管理新概念,采用“表格”数据结构,其中包含了系统所有的信息。在启动和运行时,机器会读取其中的内容以配置系统,同时几乎所有重要操作都会在其中留下蛛丝马迹。通过修改,轻易实现常规操作无法实现的功能,但如果其中的信息受到破坏,那么系统就不能正常工作。 5.“碎片”太多:新安装的系统,数据的存放是连续的。不断运行工作后使文件在硬盘上的存放位置凌乱异常。即便不出现错误,系统性能也要降低。需要定期对硬盘进行碎片整理。 6.驻留主存:任务栏右下侧的系统托盘内的图标控制会使操作带来很大的方便,但这样的方便不仅降低系统性能,而且会耗尽主存和其他系统资源,最后造成系统死机。 7.卸载不完整:不完全卸载,会在系统中产生大量的垃圾文件,从而导致系统的不稳定。 71 DOI :10.16083/j .cn ki .1671-1580.2010.12.059 SQL Server 2008 常用关键字、数据类型和常用语法 常用关键字： SQL server 2008一共大约有180多个关键字。简要分为主要关键字、辅助关键字和函数类关键字。本文就常用的这三类关键字进行语法说明和用例。 说明：1、比较好的习惯是，数据库名以D_开头，表名用T_开头，字段名以F_开头，这样可以防止和关键字重名。 2、如果确实用到了系统关键字，就要在关键上加[]方括号，以与关键字进行区别。例如有一个用户表被命名为USER，则查询该表内容的时候：SELECT * FROM USER语句是错误的，应该是SELECT * FROM [USER]。因为USER是关键字。 数据类型： SQL Server 2008一共有36种数据类型。具体如下： 常用语法： 一、数据库 【创建数据库】 CREATE DATABASE sqlserver日期函数 SQLServer时间日期函数详解,SQLServer,时间日期, 1. 当前系统日期、时间 select getdate() 2. dateadd 在向指定日期加上一段时间的基础上，返回新的datetime 值 例如：向日期加上2天 select dateadd(day,2,'2004-10-15') --返回：2004-10-17 00:00:0 0.000 3. datediff 返回跨两个指定日期的日期和时间边界数。 select datediff(day,'2004-09-01','2004-09-18') --返回：17 select datediff(day,'2004-09-18','2004-09-01') --返回：-17 4. datepart 返回代表指定日期的指定日期部分的整数。 SELECT DATEPART(month, '2004-10-15') --返回10 5. datename 返回代表指定日期的指定日期部分的字符串 SELECT datename(weekday, '2004-10-15') --返回：星期五 6. day(), month(),year() --可以与datepart对照一下 select 当前日期=convert(varchar(10),getdate(),120) ,当前时间=convert(varchar(8),getdate(),114) select datename(dw,'2004-10-15') select 本年第多少周=datename(week,'2004-10-15') ,今天是周几=datename(weekday,'2004-10-15') 函数参数/功能 GetDate( ) 返回系统目前的日期与时间 DateDiff (interval,date1,date2) 以interval 指定的方式，返回date2 与date1两个日期之间的差值 date2-date1 DateAdd (interval,number,date) 以interval指定的方式，加上number之后的日期 DatePart (interval,date) 返回日期date中，interval指定部分所对应的整数值DateName (interval,date) 返回日期date中，interval指定部分所对应的字符串名称 参数interval的设定值如下： 值缩写（Sql Server）(Access 和ASP) 说明 Year Yy yyyy 年1753 ~ 9999 Quarter Qq q 季1 ~ 4 Month Mm m 月1 ~ 12计算机操作系统(习题集)第三章_答案
《操作系统》习题集参考答案：第6章 死锁
SQLServer和Oracle语法的差异
《操作系统原理》5资源管理(死锁)习题
操作系统死锁习题集
操作系统(死锁)试题
避免死锁的方法有哪些
SQLSERVER和MYSQL语法和关键字的区别详解
第5章 死锁 练习题参考答案
操作系统之调度算法和死锁中的银行家算法习题答案
死锁的预防与避免
操作系统中死锁与死机现象的比较
SQLServer常用关键字数据类型和常用语法
sqlserver日期函数