java資料庫怎樣鎖表_java程序中如何實現對mysql資料庫中表的鎖定

A. java資料庫里什麼是鎖死

方法1：用mysql命令鎖住表.

public void test() { String sql = "lock tables aa1 write"; // 或String sql = "lock tables aa1 read"; // 如果想鎖多個表 lock tables aa1 read ,aa2 write , ..... String sql1 = "select * from aa1 "; String sql2 = "unlock tables"; try { this.pstmt = conn.prepareStatement(sql); this.pstmt1 = conn.prepareStatement(sql1); this.pstmt2 = conn.prepareStatement(sql2); pstmt.executeQuery(); pstmt1.executeQuery(); pstmt2.executeQuery(); } catch (Exception e) { System.out.println("異常" + e.getMessage()); } }

B. 北大青鳥java培訓：在Java程序中處理資料庫超時與死鎖

每個使用關系型資料庫的程序都可能遇到數據死鎖或不可用的情況，而這些情況需要在代碼中編程來解決;本文主要介紹與資料庫事務死鎖等情況相關的重試邏輯概念，此外，還會探討如何避免死鎖等問題，文章以DB2(版本9)與為例進行講解。
什麼是資料庫鎖定與死鎖鎖定(Locking)發生在當一個事務獲得對某一資源的「鎖」時，這時，其他的事務就不能更改這個資源了，這種機制的存在是為了保證數據一致性;在設計與資料庫交互的程序時，必須處理鎖與資源不可用的情況。
鎖定是個比較復雜的概念，仔細說起來可能又需要一大篇，所以在本文中，只把鎖定看作是一個臨時事件，這意味著如果一個資源被鎖定，它總會在以後某個時間被釋放。
而死鎖發生在當多個進程訪問同一資料庫時，其中每個進程擁有的鎖都是其他進程所需的，由此造成每個進程都無法繼續下去。
如何避免鎖我們可利用事務型資料庫中的隔離級別機制來避免鎖的創建，正確地使用隔離級別可使程序處理更多的並發事件(如允許多個用戶訪問數據)，還能預防像丟失修改(LostUpdate)、讀「臟」數據(DirtyRead)、不可重復讀(NonrepeatableRead)及「虛」(Phantom)等問題。
隔離級別問題現象丟失修改讀「臟」數據不可重復讀「虛」可重復讀取NoNoNoNo讀取穩定性NoNoNoYes游標穩定性NoNoYesYes未提交的讀NoYesYesYes表1：DB2的隔離級別與其對應的問題現象在只讀模式中，就可以防止鎖定發生，而不用那些未提交只讀隔離級別的含糊語句。
浙江電腦培訓http://www.kmbdqn.cn/發現一條SQL語句當使用了下列命令之一時，就應該考慮只讀模式了

C. Java如何實現對Mysql資料庫的行鎖

下面通過一個例子來說明
場景如下：
用戶賬戶有餘額，當發生交易時，需要實時更新余額。這里如果發生並發問題，那麼會造成用戶余額和實際交易的不一致，這對公司和客戶來說都是很危險的。
那麼如何避免：
網上查了下，有以下兩種方法：
1、使用悲觀鎖
當需要變更余額時，通過代碼在事務中對當前需要更新的記錄設置for update行鎖，然後開始正常的查詢和更新操作
這樣，其他的事務只能等待該事務完成後方可操作
當然要特別注意，如果使用了Spring的事務註解，需要配置一下：


<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

在指定代碼處添加事務註解

@Transactional
@Override
public boolean increaseBalanceByLock(Long userId, BigDecimal amount)
throws ValidateException {
long time = System.currentTimeMillis();
//獲取對記錄的鎖定
UserBalance balance = userBalanceDao.getLock(userId);
LOGGER.info("[lock] start. time: {}", time);
if (null == balance) {
throw new ValidateException(
ValidateErrorCode.ERRORCODE_BALANCE_NOTEXIST,
"user balance is not exist");
}
boolean result = userBalanceDao.increaseBalanceByLock(balance, amount);
long timeEnd = System.currentTimeMillis();
LOGGER.info("[lock] end. time: {}", timeEnd);
return result;
}

MyBatis中的鎖定方式，實際測試該方法確實可以有效控制，不過在大並發量的情況下，可能會有性能問題吧
<select id="getLock" resultMap="BaseResultMap" parameterType="java.lang.Long">
<![CDATA[
select * from user_balance where id=#{id,jdbcType=BIGINT} for update;
]]>
</select>

2、使用樂觀鎖
這個方法也同樣可以解決場景中描述的問題（我認為比較適合並不頻繁的操作）：
設計表的時候增加一個version（版本控制欄位），每次需要更新余額的時候，先獲取對象，update的時候根據version和id為條件去更新，如果更新回來的數量為0，說明version已經變更
需要重復一次更新操作，如下：sql腳本

update user_balance set Balance = #{balance,jdbcType=DECIMAL},Version = Version+1 where Id = #{id,jdbcType=BIGINT} and Version = #{version,jdbcType=BIGINT}

這是一種不使用資料庫鎖的方法，解決方式也很巧妙。當然，在大量並發的情況下，一次扣款需要重復多次的操作才能成功，還是有不足之處的。不知道還有沒有更好的方法。

D. 如何對「行、表、資料庫」加鎖

1
如何鎖一個表的某一行

SET TRANSACTION
ISOLATION LEVEL READ UNCOMMITTED

SELECT * FROM table ROWLOCK WHERE id = 1

2 鎖定資料庫的一個表

SELECT * FROM table WITH (HOLDLOCK)

加鎖語句：
sybase:
update 表 set col1=col1 where 1=0
;
MSSQL:
select col1 from 表 (tablockx)
where
1=0
;
oracle:
LOCK TABLE 表 IN EXCLUSIVE MODE ；

加鎖後其它人不可操作，直到加鎖用戶解鎖，用commit或rollback解鎖

幾個例子幫助大家加深印象

設table1(A,B,C)
A B C
a1 b1 c1
a2 b2 c2
a3 b3 c3

1）排它鎖
新建兩個連接
在第一個連接中執行以下語句
begin tran
update table1

set
A='aa'
where B='b2'
waitfor delay
'00:00:30' --等待30秒
commit tran

在第二個連接中執行以下語句
begin tran
select * from table1

where B='b2'
commit tran

若同時執行上述兩個語句，則select查詢必須等待update執行完畢才能執行即要等待30秒

2）共享鎖
在第一個連接中執行以下語句
begin tran
select * from table1
holdlock
-holdlock人為加鎖
where B='b2'
waitfor delay
'00:00:30' --等待30秒
commit tran

在第二個連接中執行以下語句
begin tran
select A,C
from
table1
where B='b2'
update table1

set
A='aa'
where B='b2'
commit tran

若同時執行上述兩個語句，則第二個連接中的select查詢可以執行
而update必須等待第一個事務釋放共享鎖轉為排它鎖後才能執行
即要等待30秒

3）死鎖
增設table2(D,E)
D E
d1 e1
d2 e2

在第一個連接中執行以下語句
begin tran
update table1

set
A='aa'
where B='b2'
waitfor delay
'00:00:30'
update table2

set
D='d5'
where E='e1'
commit tran

在第二個連接中執行以下語句
begin tran
update table2

set
D='d5'
where E='e1'
waitfor delay
'00:00:10'
update table1

set
A='aa'
where B='b2'
commit tran

同時執行，系統會檢測出死鎖，並中止進程

補充一點:
Sql Server2000支持的表級鎖定提示

HOLDLOCK 持有共享鎖，直到整個事務完成，應該在被鎖對象不需要時立即釋放，等於SERIALIZABLE事務隔離級別

NOLOCK 語句執行時不發出共享鎖，允許臟讀，等於 READ
UNCOMMITTED事務隔離級別

PAGLOCK 在使用一個表鎖的地方用多個頁鎖

READPAST 讓sql
server跳過任何鎖定行，執行事務，適用於READ UNCOMMITTED事務隔離級別只跳過RID鎖，不跳過頁，區域和表鎖

ROWLOCK
強制使用行鎖

TABLOCKX 強制使用獨占表級鎖，這個鎖在事務期間阻止任何其他事務使用這個表

UPLOCK
強制在讀表時使用更新而不用共享鎖

應用程序鎖:
應用程序鎖就是客戶端代碼生成的鎖，而不是sql server本身生成的鎖

處理應用程序鎖的兩個過程

sp_getapplock 鎖定應用程序資源

sp_releaseapplock
為應用程序資源解鎖

注意: 鎖定資料庫的一個表的區別

SELECT * FROM table WITH (HOLDLOCK)
其他事務可以讀取表，但不能更新刪除

SELECT * FROM table WITH (TABLOCKX)
其他事務不能讀取表,更新和刪除

1
如何鎖一個表的某一行
/*
測試環境：windows 2K server + Mssql 2000

所有功能都進行測試過，並有相應的結果集，如果有什麼疑義在論壇跟帖

關於版權的說明：部分資料來自互聯網，如有不當請聯系版主，版主會在第一時間處理。

功能：sql遍歷文件夾下的文本文件名,當然你修改部分代碼後可以完成各種文件的列表。
*/

A
連接中執行

SET TRANSACTION
ISOLATION LEVEL REPEATABLE
READ

begin tran

select * from tablename
with
(rowlock) where id=3

waitfor delay '00:00:05'

commit tran

B連接中如果執行

update tablename set
colname='10' where id=3
--則要等待5秒

update tablename
set
colname='10' where id <>3
--可立即執行

2
鎖定資料庫的一個表

SELECT * FROM table WITH (HOLDLOCK)

注意: 鎖定資料庫的一個表的區別

SELECT * FROM table WITH (HOLDLOCK)

其他事務可以讀取表，但不能更新刪除

SELECT * FROM table WITH (TABLOCKX)

其他事務不能讀取表,更新和刪除

E. 資料庫鎖表是什麼意思

1、資料庫鎖表的意思：因為在資料庫里，同一個數據可能有多個人來讀取或更改，為了防止我更改的時候別人也同時更改，這是一般要鎖住表不讓別人改。

2、舉個簡單例子：在更新資料庫記錄的過程中，我是不希望別人也來更新我的這些記錄的，像庫存，做出庫的時候，原數量100，我出了20，我就需要把數量更新到80；

在更新的過程中，別人又做了30的出庫，如果在我更新的時候，別人先把庫存更新到70，然後我又更新80，那數量就錯誤了。所以我更新的時候，我就需要鎖定這條記錄。這是數據行鎖，排他鎖。

(5)java資料庫怎樣鎖表擴展閱讀：

資料庫鎖表的必要條件：

1）互斥條件：指進程對所分配到的資源進行排它性使用，即在一段時間內某資源只由一個進程佔用。如果此時還有其它進程請求資源，則請求者只能等待，直至佔有資源的進程用畢釋放。

2）請求和保持條件：指進程已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它進程佔有，此時請求進程阻塞，但又對自己已獲得的其它資源保持不放。

3）不剝奪條件：指進程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時由自己釋放。

4）環路等待條件：指在發生死鎖時，必然存在一個進程——資源的環形鏈，即進程集合{P0，P1，P2，···，Pn}中的P0正在等待一個P1佔用的資源；P1正在等待P2佔用的資源，……，Pn正在等待已被P0佔用的資源。

F. java程序中如何實現對mysql資料庫中表的鎖定

方法1：用mysql命令鎖住表.

publicvoidtest(){

Stringsql="locktablesaa1write";
//或Stringsql="locktablesaa1read";
//如果想鎖多個表locktablesaa1read,aa2write,.....
Stringsql1="select*fromaa1";

Stringsql2="unlocktables";
try{
this.pstmt=conn.prepareStatement(sql);
this.pstmt1=conn.prepareStatement(sql1);
this.pstmt2=conn.prepareStatement(sql2);
pstmt.executeQuery();
pstmt1.executeQuery();
pstmt2.executeQuery();

}catch(Exceptione){
System.out.println("異常"+e.getMessage());
}

}

對於read lock 和 write lock官方說明：
1.如果一個線程獲得一個表的READ鎖定，該線程（和所有其它線程）只能從該表中讀取。
如果一個線程獲得一個表的WRITE鎖定，只有保持鎖定的線程可以對表進行寫入。
其它的線程被阻止，直到鎖定被釋放時為止。

2.當您使用LOCK TABLES時，您必須鎖定您打算在查詢中使用的所有的表。
雖然使用LOCKTABLES語句獲得的鎖定仍然有效，但是您不能訪問沒有被此語句鎖定的任何的表。
同時，您不能在一次查詢中多次使用一個已鎖定的表——使用別名代替，
在此情況下，您必須分別獲得對每個別名的鎖定。

對與read lock 和 write lock個人說明：
1.read lock 和 write lock 是線程級(表級別).
2.在同一個會話中加了read lock鎖. 只能對這個表進行讀操作.對這個表以外的任何錶都無法進行增、刪、改、查的操作.
但是在不同會話中，只能對加了read lock的表進行讀操作.但可以對read lock以外的表進行增、刪、改、查的操作.
3.在同一個會話中加了write lock鎖.只能對這個表進行讀、寫操作.對這個表以外的任何錶都無法進行增、刪、改、查的操作.
但是在不同會話中,無法對加了write lock的表進行讀、寫操作.但可以對write lock以外的表進行增、刪、改、查的操作.
4.如果表中使用了別名.(SELECT * FROM aa1 AS byname_table)
在對aa1加鎖時，必須把別名加上去(lock tables aa1 as byname_table read)
在同一個會話中.必須使用別名進行查詢.
在不同的會話中.可以不需要使用別名進行查詢.
5.在多個會話中可以對同一個表進行lock read操作.但不能在多個會話中對同一個表進行lock write操作（這些鎖將等待已鎖的表釋放自身的線程鎖）
如果多個會話對同一個表進行lock read操作.那麼在這些會話中,也只能對以鎖的表進行讀操作.
6.如果要你鎖住了一個表，需要嵌套查詢.你必須使用別名，並且，要鎖定別名.
例如.lock table aa1 read ,aa1 as byname_table read;
select * from aa1 where id in (select * from aa1 as xxwhere id=2);
7.解鎖必須用unlock tables;

另:
在JAVA程序中,要想解鎖,需要調用 unlock tables來解鎖.
如果沒有調用unlock tables.
關閉connection 、程序結束、調用GC 都能解鎖.

方法2：用記錄鎖鎖表.

publicvoidtest(){

Stringsql="select*fromaa1forupdate";
//select*fromaa1lockinsharemode;

try{
conn.setAutoCommit(false);
this.pstmt=conn.prepareStatement(sql);
pstmt.executeQuery();

}catch(Exceptione){
System.out.println("異常"+e.getMessage());
}

}

1.for update 與 lock in share mode 屬於行級鎖和頁級鎖

2.for update 排它鎖,lock in share mode 共享鎖

3.對於記錄鎖.必須開啟事務.

4.行級鎖定事實上是索引記錄的鎖定.只要是用索引掃描的行（或沒索引全表掃描的行）,都將被鎖住.

5.在不同的隔離級別下還會使用next-key locking演算法.即所掃描的行之間的「間隙」也會也鎖住(在Repeatable read和Serializable隔離級別下有間隙鎖).

6.在mysql中共享鎖的含義是:在被共享鎖鎖住的行,即使內容被修改且並沒有提交.在另一個會話中依然看到最新修改的信息.

在同一會話中加上了共享鎖.可以對這個表以及這個表以外的所有表進行增、刪、改、查的操作.

在不同的會話中.可以查到共享鎖鎖住行的最新消息.但是在Read Uncommitted隔離級別下不能對鎖住的表進行刪，

改操作.（需要等待鎖釋放才能操作...）
在Read Committed隔離級別下不能對鎖住的表進行刪，改操作.（需要等待鎖釋放才能操作...）
在Repeatable read隔離級別下不能對鎖住行進行增、刪、改操作.（需要等待鎖釋放才能操作...）
在Serializable隔離級別下不能對鎖住行進行增、刪、改操作.（需要等待鎖釋放才能操作...）

7.在mysql中排他鎖的含義是:在被排它鎖鎖住的行,內容修改並沒提交，在另一個會話中不會看到最新修改的信息。

在不同的會話中.可以查到共享鎖鎖住行的最新消息.但是Read Uncommitted隔離級別下不能對鎖住的表進行刪，

8.在同一個會話中的可以疊加多個共享鎖和排他鎖.在多個會話中,需要等待鎖的釋放.

9.SQL中的update 與 for update是一樣的原理.

10.等待超時的參數設置:innodb_lock_wait_timeout=50 (單位秒).

11.任何可以觸發事務提交的命令,都可以關閉共享鎖和排它鎖.

G. java實現oracle資料庫寫鎖

ConnectOracle con = new ConnectOracle();
Connection connect = con.getConnection();
// 設置手動提交事務
connect.setAutoCommit(false);
Statement stmt = connect.createStatement();
// 鎖表
stmt.addBatch("lock table t_symbol_code_fee in exclusive mode");
// 此處打上斷點後，執行另一個類，你會發現，執行成功後並沒有更改記錄，因為表已經被鎖定。只有提交事務後，TestOracle中執行的修改才能生效。
stmt.executeBatch();
// 提交後自動解鎖，回滾時也會自動解鎖
connect.commit();
stmt.close();
connect.close();

H. 關於java操作資料庫鎖的問題

1. 使用synchronized同步該查詢方法
2. 使用select * from tablename for update，但並非所有資料庫都會提供支持

I. java如何給資料庫加行鎖

與java無關，要用sql語句實現
前提目標表要有索引，查詢要開啟事物，使用select * from tb with(updlock) where col ＝ xxx將一行數據鎖住，其他連接不能再修改表

J. 在java 中操作資料庫時，怎麼鎖表

首先synchronized不可能做到對某條資料庫的數據加鎖。它能做到的只是對象鎖。比如數據表table_a中coloum_b的數據是臨界數據，也就是你說的要保持一致的數據。你可以定義一個類，該類中定義兩個方法read()和write()(注意，所有有關該臨界資源的

java資料庫怎樣鎖表

(5)java資料庫怎樣鎖表擴展閱讀：

與java資料庫怎樣鎖表相關的內容