mysqljava事务

1. javamysql乐观锁为什么能防止死锁

数据库中有两种基本的锁类型：
排它锁（Exclusive Locks，即X锁）
共享锁（Share Locks，即S锁）。
当数据对象被加上排它锁时，其他的事务不能对它读取和修改。加了共享锁的数据对象可以被其他事务读取，但不能修改。数据库利用这两种基本的锁类型来对数据库的事务进行并发控制。

2. java线程中使用mysql连接查询数据库

不建议这样做，一般不符合开发规范，如果这样的话，你想想在业务量多的情况下，多个线程如果不控制，数据库连接会将数据库服务器爆掉的，会影响业务的
常规做法：数据库连接池（rid了解一下），据某些统计哈，真正用来做查询的资源不超过整个查询数据库的生命周期的30%，大部分时间都用开创建连接关闭连接等操作，如果这个时候建立数据库连接池的话，可以有效的将这部分时间释放掉

3. Mysql数据归档如何实现利用Java

用mysql的job（作业）每天定时备份数据，不需要java参与

4. 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隔离级别下不能对锁住的表进行删，

改操作.（需要等待锁释放才能操作...）
在Read Committed隔离级别下不能对锁住的表进行删，改操作.（需要等待锁释放才能操作...）
在Repeatable read隔离级别下不能对锁住行进行增、删、改操作.（需要等待锁释放才能操作...）
在Serializable隔离级别下不能对锁住行进行增、删、改操作. （需要等待锁释放才能操作...）

8.在同一个会话中的可以叠加多个共享锁和排他锁.在多个会话中,需要等待锁的释放.

9.SQL中的update 与 for update是一样的原理.

10.等待超时的参数设置:innodb_lock_wait_timeout=50 (单位秒).

11.任何可以触发事务提交的命令,都可以关闭共享锁和排它锁.

5. 如何用java开启mysql事务，要求详细

看你是什么事务，jdbc事务，还是分布式事务，还是容器事务
1，编程式事务管理（jdbc的事务是绑定在connection上的）
Connection conn = null;
try
{
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:oracle:thin:@host:1521:SID","username","password");
conn.setAutoCommit(false); //取消自动提交
PreparedStatement ps = conn.prepareCall("update something");
ResultSet rs = ps.executeQuery();
conn.commit(); //手动提交
}
catch (Exception e)
{
conn.rollback();
e.printStackTrace();
}
finally
{
conn.close();
}
2，声明式事务
先在工程的application.xml配置文件中添加如下代码，开启事务
<!-- 声明式事务控制配置 -->
<tx:annotation-driven transaction-manager="txManager"/>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="datasource" ref="bassDataSource"></property>
</bean>
然后在你需要开启事务的接口前面添加注解
@Transactional(rollbackFor = IOException.class)
public void add(String name) throws IOException
{
System.out.println("可以再类里和方法里面添加事务注解0~0");
throw new IOException();
}
直接调用接口方法就好
分布式事务处理（mysql貌似在5.X之后才支持） 的话，
1.可以直接使用spring+atomikos框架进行管理
参考：
就不贴测试代码了，自己看着配置吧
2，使用JTA（Java Transaction API）进行分布式事务管理（测试代码如下）
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import javax.transaction.SystemException;
import javax.transaction.UserTransaction;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
//分布式事务处理
public class transferAccount
{
@SuppressWarnings("null")
public void testTransferAccount()
{
UserTransaction userts = null;
Connection connA = null;
PreparedStatement psA = null;
InitialContext context = null;
Connection connB = null;
PreparedStatement psB = null;
try
{
//获得事务管理对象
userts = (UserTransaction) context.lookup("java:comp/UserTransaction");
//获取两个数据库
connA = getDataSourceA().getConnection();
connB = getDataSourceB().getConnection();
//开启事务
userts.begin();
//sql语句
psA = connA.prepareStatement("我加1");
psB = connB.prepareStatement("我减1");
//执行sql
psA.executeUpdate();
psB.executeUpdate();
//事务提交
userts.commit();
} catch (Exception e)
{
try
{
userts.rollback();
} catch (IllegalStateException | SecurityException
| SystemException e1)
{
e1.printStackTrace();
}
e.printStackTrace();
}
finally
{
try
{
psA.close();
psB.close();
connA.close();
connB.close();
} catch (SQLException e)
{
e.printStackTrace();
}
}
}
public DataSource getDataSourceA()
{
MysqlDataSource dataSource = new MysqlDataSource();
dataSource.setDatabaseName("mysql");
dataSource.setServerName("server");
dataSource.setPortNumber(1433);
dataSource.setUser("test");
dataSource.setPassword("test");
return dataSource;
}
public DataSource getDataSourceB()
{
MysqlDataSource dataSource = new MysqlDataSource();
dataSource.setDatabaseName("mysql");
dataSource.setServerName("server");
dataSource.setPortNumber(1435);
dataSource.setUser("test1");
dataSource.setPassword("test1");
return dataSource;
}
}

6. mysql大并发，报 java.sql.SQLException: Lock wait timeout exceeded; try restarting transaction 错误

处理过类似的问题，原因可能是你的连接太频繁，客户端太多，这里没看到你的具体表结构和业务逻辑，仅能提供一些经验：

1. 检查访问的业务表的索引是否存在多个唯一索引（包括主键），如果是尽量保持主键，删除其他的唯一索引；

2. 避免客户端访问时的多表联合和复杂的子查询，如果无法解决，从数据库中对表的结构进行调优，尽量让客户端的访问一步抵达，减少中间运算过程；

3. select不会锁表，只有update或insert才会导致锁表，一定避免 insert into *** select ** from的结构，这个你可以详细的查看Mysql的锁表机制，尽量避免在高并发情况使用对表的批量写操作；

4. 高并发下客户端对表的写操作最好根据主键1对1的操作，比如update table set A = B where id = 3，看起来不高效，但实际上效果很好，一定不会产生锁表的问题，因为这样在排队的时候就不会把优先级的逻辑运算交由mysql自己处理，也不会出现阻塞的情况；

7. java操作MYSQL,高手来，怎么同时执行两条语句，如果table_1新插入“待发送”，如何同步

private Connection conn = null;
private PreparedStatement ps = null;

try {
conn.setAutoCommit(false); //将自动提交设置为false

ps.executeUpdate("修改SQL"); //执行修改操作
ps.executeQuery("查询SQL"); //执行查询操作
conn.commit(); //当两个操作成功后手动提交

} catch (Exception e) {
conn.rollback(); //一旦其中一个操作出错都将回滚，使两个操作都不成功
e.printStackTrace();
}

事务的特性：
1) 原子性（atomicity）：事务是数据库的逻辑工作单位，而且是必须是原子工作单位，对于其数据修改，要么全部执行，要么全部不执行。
2) 一致性（consistency）：事务在完成时，必须是所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。
3) 隔离性（isolation）：一个事务的执行不能被其他事务所影响。
4) 持久性（rability）：一个事务一旦提交，事物的操作便永久性的保存在DB中。即使此时再执行回滚操作也不能撤消所做的更改。

8. java 调用mysql的事务如何传入查询参数

Statement换成preparedStatement，就有相应的set方法了。

或者既然addBatch里面传入的是String类型，那我们自己构造，

stmt.addBatch(“insertintousersvalues("+"values1"+","+"values2"+");");

或者既然是users类，我们可以根据users中属性是否为初始值来自动生成inset语句，下面是我以前写的代码，仅供参考

注释：

1、下面的User.NAME等就是user中name属性在表中的列名

2、方法ConvertStr就是把插入的列的value加上单引号。

privatestaticStringConvertStr(Objectobject){

return"'"+object.toString()+"'";

}

3、其他

publicstaticfinalStringstrIns="insertintousers(";

publicstaticfinalStringstrVal=")values(";

publicstaticfinalStringstrEnd=");";

4、调用

stmt.addBatch(User.InsetStr(user));//这样就不用考虑传参了

代码如下：

public static String InsetStr(User user) {
        String StrCol = "";
        String Values = "";
        if (user.getName() != null && !user.getName().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.NAME;
                Values = Values + "," + ConvertStr(user.getName());
            } else {
                StrCol = StrCol + User.NAME;
                Values = Values + ConvertStr(user.getName());
            }
        }
        if (user.getNick() != null && !user.getNick().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.NICK;
                Values = Values + "," + ConvertStr(user.getNick());
            } else {
                StrCol = StrCol + User.NICK;
                Values = Values + ConvertStr(user.getNick());
            }
        }
        if (user.getStudentid() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.STUDENTID;
                Values = Values + "," + ConvertStr(user.getStudentid());
            } else {
                StrCol = StrCol + User.STUDENTID;
                Values = Values + ConvertStr(user.getStudentid());
            }
        }
        if (user.getSex() != 'u0000') {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.SEX;
                Values = Values + "," + ConvertStr(user.getSex());
            } else {
                StrCol = StrCol + User.SEX;
                Values = Values + ConvertStr(user.getSex());
            }
        }
        if (user.getPassword() != null && !user.getPassword().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.PASSWORD;
                Values = Values + "," + ConvertStr(user.getPassword());
            } else {
                StrCol = StrCol + User.PASSWORD;
                Values = Values + ConvertStr(user.getPassword());
            }
        }
        if (user.getHash() != null && !user.getHash().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.HASH;
                Values = Values + "," + ConvertStr(user.getHash());
            } else {
                StrCol = StrCol + User.HASH;
                Values = Values + ConvertStr(user.getHash());
            }
        }
        if (user.getSchool() != null && !user.getSchool().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.SCHOOL;
                Values = Values + "," + ConvertStr(user.getSchool());
            } else {
                StrCol = StrCol + User.SCHOOL;
                Values = Values + ConvertStr(user.getSchool());
            }
        }
        if (user.getMajor() != null && !user.getMajor().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.MAJOR;
                Values = Values + "," + ConvertStr(user.getMajor());
            } else {
                StrCol = StrCol + User.MAJOR;
                Values = Values + ConvertStr(user.getMajor());
            }
        }
        if (user.getMobile() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.MOBILE;
                Values = Values + "," + ConvertStr(user.getMobile());
            } else {
                StrCol = StrCol + User.MOBILE;
                Values = Values + ConvertStr(user.getMobile());
            }
        }
        if (user.getCollege() != null && !user.getCollege().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.COLLEGE;
                Values = Values + "," + ConvertStr(user.getCollege());
            } else {
                StrCol = StrCol + User.COLLEGE;
                Values = Values + ConvertStr(user.getCollege());
            }
        }
        if (user.getGrade() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.GRADE;
                Values = Values + "," + ConvertStr(user.getGrade());
            } else {
                StrCol = StrCol + User.GRADE;
                Values = Values + ConvertStr(user.getGrade());
            }
        }
        if (user.getBclass() != null && !user.getBclass().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.BCLASS;
                Values = Values + "," + ConvertStr(user.getBclass());
            } else {
                StrCol = StrCol + User.BCLASS;
                Values = Values + ConvertStr(user.getBclass());
            }
        }
        if (user.getIdnum() != null && !user.getIdnum().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.IDNUM;
                Values = Values + "," + ConvertStr(user.getIdnum());
            } else {
                StrCol = StrCol + User.IDNUM;
                Values = Values + ConvertStr(user.getIdnum());
            }
        }
        if (user.getEmail() != null && !user.getEmail().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.EMAIL;
                Values = Values + "," + ConvertStr(user.getEmail());
            } else {
                StrCol = StrCol + User.EMAIL;
                Values = Values + ConvertStr(user.getEmail());
            }
        }
        if (user.getRegip() != null && !user.getRegip().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.REGIP;
                Values = Values + "," + ConvertStr(user.getRegip());
            } else {
                StrCol = StrCol + User.REGIP;
                Values = Values + ConvertStr(user.getRegip());
            }
        }
        if (user.getRegdate() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.REGDATE;
                Values = Values + "," + ConvertStr(user.getRegdate());
            } else {
                StrCol = StrCol + User.REGDATE;
                Values = Values + ConvertStr(user.getRegdate());
            }
        }
        if (user.getUnit() != null && !user.getUnit().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.UNIT;
                Values = Values + "," + ConvertStr(user.getUnit());
            } else {
                StrCol = StrCol + User.UNIT;
                Values = Values + ConvertStr(user.getUnit());
            }
        }
        if (user.getRegion() != null && !user.getRegion().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.REGION;
                Values = Values + "," + ConvertStr(user.getRegion());
            } else {
                StrCol = StrCol + User.REGION;
                Values = Values + ConvertStr(user.getRegion());
            }
        }
        if (user.getDepartments() != null && !user.getDepartments().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.DEPARTMENTS;
                Values = Values + "," + ConvertStr(user.getDepartments());
            } else {
                StrCol = StrCol + User.DEPARTMENTS;
                Values = Values + ConvertStr(user.getDepartments());
            }
        }
        if (user.getTdcj() > 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.TDCJ;
                Values = Values + "," + ConvertStr(user.getTdcj());
            } else {
                StrCol = StrCol + User.TDCJ;
                Values = Values + ConvertStr(user.getTdcj());
            }
        }
        if (user.getTzcj() > 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.TZCJ;
                Values = Values + "," + ConvertStr(user.getTzcj());
            } else {
                StrCol = StrCol + User.TZCJ;
                Values = Values + ConvertStr(user.getTzcj());
            }
        }
        if (user.getAddress() != null && !user.getAddress().equals("")) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.ADDRESS;
                Values = Values + "," + ConvertStr(user.getAddress());
            } else {
                StrCol = StrCol + User.ADDRESS;
                Values = Values + ConvertStr(user.getAddress());
            }
        }
        if (user.getPostcode() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.POSTCODE;
                Values = Values + "," + ConvertStr(user.getPostcode());
            } else {
                StrCol = StrCol + User.POSTCODE;
                Values = Values + ConvertStr(user.getPostcode());
            }
        }
        if (user.getBankcard() != 0) {
            if (!StrCol.equals("")) {
                StrCol = StrCol + "," + User.BANKCARD;
                Values = Values + "," + ConvertStr(user.getBankcard());
            } else {
                StrCol = StrCol + User.BANKCARD;
                Values = Values + ConvertStr(user.getBankcard());
            }
        }
        return Sql.strIns + StrCol + Sql.strVal + Values + Sql.strEnd;
    }

9. 大数据分析师面试必备：java与mysql解析

【导读】作为大数据工程师，其必须要掌握的基础知识就是java与mysql的关系、交互和连接，作为基础，也是面试考官经常会考的内容，为了帮助大家都能顺利通过考试，今天小编就来和大家唠一唠java与mysql的关系、交互和连接，好了，开始今天的内容大数据分析师面试必备：java与mysql解析。

1. SQL语言四大类：

DQL 数据查询语言 select

DML 数据操作语言 insert、update、delete

DDL 数据界说语言 create、alter

DCL 数据控制语言 grant权限

2. mysql数据库中的decimal类型(是数值型，不能存放字符串)：

举例：decimal(18,0) 常用于身份证号码，但是带x的不可以。

举例：decimal(5,2)

状况一：假设小数点前面是3位，后边是2位，正常状况。

状况二：5指的是小数点前后不能超过5位，小数点后有必要是2位。

3. mysql中InnoDB和MyISAM引擎的差异：

innodb支撑：事务和主外键

myisam不支撑：事务和主外键

4. 【不需要背诵，选择题考点】向mysql中，a向表中添加数据的几种写法，题目：id int 主键自增，name varchar(11)
不为空。

5. 操作mysql数据库表有两种方式，第一种：点八点吧;第二种：写代码。【不需要背诵，只需要了解，考试选择题会出】

6. 在Java中，简述面向对象三大特征。

7. 在Java中，常用关键字：

1. 定义类的关键字是什么? class

2. 继承的关键字是什么? extends

3. 定义接口的关键字是什么? interface

4. 实现接口的关键字是什么? implements

5. 抽象类的关键字是什么? abstract

8. 在Java中，抽象类和接口的区别：

1. 抽象类中可以包含普通方法和抽象方法，接口中只能包含抽象方法

2. 抽象类中可以有构造方法，接口中没有构造方法

3. 抽象类只能单继承，可以实现多个接口

9. Java接口中有哪些成员?

1. 构造方法，没有

2. 常量，默认访问修饰符public static final，没有变量

3. 抽象方法，默认访问修饰符public abstract

10. 在Java中，抽象类和抽象方法的关系：

1. 抽象类中可以包含普通方法和抽象方法，抽象方法一定存在抽象类中。

2. 子类继承抽象父类，必须实现|重写抽象方法，除非子类也是抽象类。

3. 【判断题】抽象类中必须包含抽象方法?【错误×】

4. 【判断题】抽象方法一定存在抽象类中?【正确√】

11. Java重载的特点：

1. 在同一个类中

2. 方法名相同

3. 参数列表(个数、类型、顺序)不同

4. 与返回值类型和访问修饰符无关

12. Java重写的特点：

1. 在父子类中

2. 方法名相同

3. 参数列表相同

4. 返回值类型相同，或是其子类

5. 访问修饰符相同，或不能严于父类

13. 列举几种Java实现多态的形式：

1. 继承的存在

2. 父类引用指向子类对象 | 向上转型

3. 父类作为方法的返回值类型，父类作为方法的参数

14. Java接口的特性：单根性和传递性

15. 在Java中，throws和throw的区别：

1. throws 声明异常，用在定义方法小括号的后面

2. throw 抛出异常，写在方法体内

以上就是小编今天给大家整理发送的关于大数据分析师面试必备：java与mysql解析的相关内容，希望对各位考生有所帮助，想知道更多关于数据分析师的基本要求有哪些，关注小编持续更新数据分析师岗位解析。