oracle吗?查看这个Java登录的session的用户,用这个用户登录sqlplus再执行上面的语句看,java.util.NoSuchElementException应该是权限问题,没法访问这些表,相当于当前用户的schema下没有这些表
创新互联致力于互联网网站建设与网站营销，提供做网站、网站建设、网站开发、seo优化、网站排名、互联网营销、微信小程序、公众号商城、等建站开发，创新互联网站建设策划专家，为不同类型的客户提供良好的互联网应用定制解决方案，帮助客户在新的全球化互联网环境中保持优势。
下面通过一个例子来说明
场景如下：
用户账户有余额，当发生交易时，需要实时更新余额。这里如果发生并发问题，那么会造成用户余额和实际交易的不一致，这对公司和客户来说都是很危险的。
那么如何避免：
网上查了下，有以下两种方法：
1、使用悲观锁
当需要变更余额时，通过代码在事务中对当前需要更新的记录设置for update行锁，然后开始正常的查询和更新操作
这样，其他的事务只能等待该事务完成后方可操作
当然要特别注意，如果使用了Spring的事务注解，需要配置一下：
!-- (事务管理)transaction manager, use JtaTransactionManager for global tx --
bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
property name="dataSource" ref="dataSource" /
/bean
!-- 使用annotation定义事务 --
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}
这是一种不使用数据库锁的方法，解决方式也很巧妙。当然，在大量并发的情况下，一次扣款需要重复多次的操作才能成功，还是有不足之处的。不知道还有没有更好的方法。
数据库是 oracle?
直接select * from 表 where id='xxxx' for update
然后程序里面不commit 就锁了这条数据了
当然可行.我不知道你的理解是在什么地方切入的.但是这个问题不太需要涉及到JDBC也就是数据库的读写的内容.
实际上的理解你应该紧扣住"实体"这个关键点.JDBC只不过是达到目的的一个手段,实体Bean作为参数在不同的类之间传递才是关键.
我们举个例子,这个bank表简单的具有:ID, bank_name, address 这3个属性.而实际的项目中,往往一张表能有十几个字段甚至更多.
一开始的时候,程序员们都是这样来读取数据库: 例如这张bank表,从数据库把某一个ID=1的记录读出来以后,直接把3个字段值返回给调用该数据库类的方法(例如可以采用封装到一个数组中去的方法).这样当字段变多以后会变得非常的麻烦, 例如,很可能一不小心把返回的字段给弄颠倒了.
后来这样的方法进过改进,就成了现在的以实体类封装数据并进行传递的方式.例如一张订单表:你尽管可能觉得order_date和order_data这2个字段非常容易混淆.但是如果date是日期类型,data是String类型,那么你怎么也不可能把这2个值赋予给错误的属性.
那么在使用中,首先,你读出了数据之后,我们再拿bank表作例子,ID=1的表里的数据如下:ID=1,name=abc,address=nanjing,那么你实例化一个bank类,然后把这3个值一一 赋予对应的属性(调用set方法)
而在将这个实体类返回调用者之后,可以调用get方法来查看.
如果需要看具体的代码的话可以继续追问
可能是之前对该表执行的事务未完成，导致有锁，所以用sql又查不出来，但是java代码能查出来有一条数据。建议先在数据库中查询是否有未完成的事务及是否有锁，如果有，先commit，提交，确保表没锁，这样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());
}
}
对于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 xx where id=2);
7.解锁必须用unlock tables;
另:
在JAVA程序中,要想解锁,需要调用 unlock tables来解锁.
如果没有调用unlock tables.
关闭connection 、程序结束 、调用GC 都能解锁.
方法2：用记录锁锁表.
public void test() {
String sql = "select * from aa1 for update";
// select * from aa1 lock in share mode;
try {
conn.setAutoCommit(false);
this.pstmt = conn.prepareStatement(sql);
pstmt.executeQuery();
} catch (Exception e) {
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隔离级别下不能对锁住的表进行删，
改操作.（需要等待锁释放才能操作...）
在Read Committed隔离级别下不能对锁住的表进行删，改操作.（需要等待锁释放才能操作...）
在Repeatable read隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
在Serializable隔离级别下不能对锁住行进行增、删、改操作. （需要等待锁释放才能操作...）
8.在同一个会话中的可以叠加多个共享锁和排他锁.在多个会话中,需要等待锁的释放.
9.SQL中的update 与 for update是一样的原理.
10.等待超时的参数设置:innodb_lock_wait_timeout=50 (单位秒).
11.任何可以触发事务提交的命令,都可以关闭共享锁和排它锁.