【计算机基础】数据库悲观锁和线程安全

浅浅的花香味﹌ 2023-07-17 14:08 2阅读 0赞

**目录**

第一种：synchronized

第二种： 数据库中使用悲观锁，在sql语句后添加for update，对事物进行处理

--------------------

场景：有一个数据库表可能会出现多人同时修改的问题。

保证在修改表格的时候，线程安全，可以保证多个用户同时查询和修改表格的时候，不会出现冲突，两种办法：

1.  在代码中添加锁synchronized
2.  在数据库中使用悲观锁 for update

### 第一种：synchronized ###

> 1、是静态的对方法进行加锁 synchronized
> 
> 2、非静态方法加锁
> 
> 3、 也可以对某部分代码块进行加锁 synchronized(this)
> 
>     1、 public static synchronized int generate(String tableName) \{\}
> 
>      2、  public synchronized int generate(String tableName) \{\}
> 
>      3、 synchronized(this) \{\}

### 第二种： 数据库中使用悲观锁，在sql语句后添加for update，对事物进行处理 ###

package util;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    
    /**
    * id生成工具类
    * @author Administrator
    *
    */
    public class IdGenerator {
    
    
       /**
        * 查询该表格当前的id值
        * @param tableName
        * @return id值
        */
       public static int generate(String tableName) {
          //数据库的悲观锁for update
          // 不管要对数据进行什么扫错先把查询的数据锁住，然后在进行操作，完成后手动释放锁
          String sql = "select value from t_table_id where table_name=? for update";
          Connection conn = null;
          PreparedStatement pstmt = null;
          ResultSet rs = null;
          int value = 0;
          try {
             // 链接数据库
             conn = DbUtil.toConnection();
             // 手动开始事物（原则、一致、隔离、持续的特点）
             DbUtil.beginTransaction(conn);
             pstmt = conn.prepareStatement(sql);
             pstmt.setString(1, tableName);
             rs = pstmt.executeQuery();
             if (!rs.next()) {
                throw new RuntimeException();
             }
             // 获取到当前表格的id值自加
             value = rs.getInt("value");
             value++;
             // 调用更新管理id表格的值的方法
             modifyValueField(conn, tableName, value);
             // 提交事物
             DbUtil.commitTransaction(conn);
          }catch(Exception e) {
             e.printStackTrace();
             // 这里catch住了错误，那么回滚事物，对数据回滚到修改前
             DbUtil.rollbackTransaction(conn);
             throw new RuntimeException();
          }finally {
             DbUtil.close(rs);
             DbUtil.close(pstmt);
             DbUtil.resetConnection(conn); // 修改事物的默认值
             DbUtil.close(conn);
          }
          return value;
       }
       
    }

因为需要对当前操作加锁，所以需要自己对当前线程是否执行完，什么时候释放资源，要自己掌控，这里用了事物来管理当前线程。在链接数据库后要把sql语句发给数据库之前，把自动提交，编程手动提交，如果事物没有执行完，进行回滚。

/*关于事物的方法
    * 启动事物
    * */
    public static void beginTransaction(Connection conn) {
        try {
            if (conn != null) {
                if (conn.getAutoCommit()) {
                    conn.setAutoCommit(false); //自动提交设置为false
                    // 手动提交
                }
            }
        }catch(SQLException e) {}
    }
    
    
    /* 提交事物*/
    public static void commitTransaction(Connection conn) {
        try {
            if (conn != null) {
                if (!conn.getAutoCommit()) {
                    conn.commit();
                }
            }
        }catch(SQLException e) {}
    }
    
    
    /*回滚事物*/
    public static void rollbackTransaction(Connection conn) {
        try {
            if (conn != null) {
                if (!conn.getAutoCommit()) {
                    conn.rollback();
                }
            }
        }catch(SQLException e) {}
    }
    
    
    /*重置事物的状态*/
    public static void resetConnection(Connection conn) {
        try {
            if (conn != null) {
                //  如果自动提交时true改为 false
                if (conn.getAutoCommit()) {
                    conn.setAutoCommit(false);
                }else {
                    conn.setAutoCommit(true);
                }
            }
        }catch(SQLException e) {}
    }