jdbc

Question

用单例类封装数据库操作，简略代码如下：
public final class DBCommon {  
  
  
   private DBCommon() {
                       //这里配置数据库连接池信息    } 
    
 public static DBCommon getInstance() {  
        // 应用单例[件]模式确保类本身只有一个实例  
        if (dbCommon == null) {  
            dbCommon = new DBCommon();  
        }  
        // 返回类本身的实例  
        return dbCommon;  
    } 
 private Connection getConnection() {//从数据库连接池获取connection
   }
private PreparedStatement getPreparedStatement{//获取PreparedStatement}   
public ResultSet executeQuery(String sql){//获取ResultSet
}
我的疑问是数据库连接池只有一个，Connection对象有多个，getConnection()方法前面要不要synchronized来防止线程并发来防止多线程并发

Answer 1

synchronized来防止线程并发来防止多线程并发
是有必要的

Answer 2

PreparedStatement getPreparedStatement和ResultSet executeQuery(String sql）是从connection中获取的，connection有多个，应该加synchronized吧

Answer 3

synchronized应该加的，正在获取的时候不能并发的，所以必须加的，不过最好用成熟连接池，效率会是个质的提高，这些问题就不用考虑了。

Answer 4

PreparedStatement getPreparedStatement和ResultSet executeQuery(String sql）是从connection中获取的，connection有多个，这两个方法应该是不需要加吧！

Answer 5

Connection对象有多个的话 是有必要加上synchronized的但是能否请楼主说下你是怎么有多个 Connection 对象的？
有些人经常误解有多个Connection 对象 其实只有一个。

Answer 6

给你连接oracle的例子package com.ccit.xyy.util;import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;import oracle.jdbc.driver.OracleDriver;import com.ccit.xyy.util.staconstant.Constant;
/**
 * @author XYY
 * @创建时间 2010年02月20日23点05分
 * @version 1.0
 * @描述 连接数据库，未使用数据源
 * @类名 DBUtilsTwo
 */
public class DBUtilsTwo { private static DBUtilsTwo instance = null; public static synchronized Connection getConnection() { if (instance == null) {
instance = new DBUtilsTwo();
}
Connection conn = null;
OracleDriver driver = new OracleDriver();
try {
DriverManager.registerDriver(driver);
conn = DriverManager.getConnection(Constant.getDB_URL_ORACLE(),
Constant.getDB_USER_ORACLE(), Constant
.getDB_PASSWORD_ORACLE());
} catch (SQLException e) {
e.printStackTrace();
} return conn;
}
/**
 * 关闭连接
 * @param conn
 * @param pstmt
 * @param rs
 */
public static void finalize(Connection conn, PreparedStatement pstmt,
ResultSet rs) { if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if (conn != null) {
try {
if (!conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
 * 关闭连接（无结果集）
 * @param conn
 * @param pstmt
 */
public static void finalize(Connection conn, PreparedStatement pstmt) { if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if (conn != null) {
try {
if (!conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
 * 关闭连接
 * @param conn
 * @param cstmt
 * @param rs
 */
public static void finalize(Connection conn, CallableStatement cstmt,
ResultSet rs) { if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

if (cstmt != null) {
try {
cstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if (conn != null) {
try {
if (!conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
 * 关闭连接（无结果集）
 * @param conn
 * @param cstmt
 */
public static void finalize(Connection conn, CallableStatement cstmt) { if (cstmt != null) {
try {
cstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if (conn != null) {
try {
if (!conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}}

Answer 7

恩, 线程并发的时候, 肯定要用到synchronized

Answer 8

数据库连接池不是可以创建多个Connection对象吗？

Answer 9

synchronized应该加的，正在获取的时候不能并发的，所以必须加的，不过最好用成熟连接池，效率会是个质的提高，这些问题就不用考虑了。