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数据库怎样锁表相关的内容