java多线程高并发下的oracle数据库异常

代码的功能是生成一个随机的序列化的订单号,正常的情况下一个一个跑没问题,在进行压力测试的时候,多线程高并发下,oracle的create语句就会报错,说是
java.lang.RuntimeException: org.springframework.jdbc.BadSqlGrammarException: ConnectionCallback; bad SQL grammar []; nested exception is java.sqlSQLException: ORA-00955: 名称已由现有对象使用
求大神看下。
代码如下:

 package utils.spring;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCallback;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
import utils.Lang;

import javax.sql.DataSource;
import java.sql.*;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 序列发生器(可用于高并发、可回收等场景)
 *
 * @author lujijiang
 *
 */
@Component
@ConfigurationProperties(prefix = "seqGenerator")
final public class SequenceGenerator implements InitializingBean {

    interface Atom<T> {
        T atom(Connection connection) throws Exception;
    }

    public static <T> T atom(Connection connection, Atom<T> atom)
            throws Exception {
        connection.setAutoCommit(false);
        connection
                .setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        try {
            T obj = atom.atom(connection);
            connection.commit();
            return obj;
        } catch (Exception e) {
            connection.rollback();
            throw e;
        }
    }

    static Map<String, String> createSqlMap = new ConcurrentHashMap<String, String>();
    static {
        createSqlMap
                .put("h2",
                        "CREATE TABLE %s (v$key BIGINT NOT NULL,v$key$ varchar(256),v$seq BIGINT NOT NULL,v$state CHAR(1) NOT NULL, PRIMARY KEY (v$key,v$seq))");
        createSqlMap
                .put("mysql",
                        "CREATE TABLE %s (v$key BIGINT NOT NULL,v$key$ varchar(256),v$seq BIGINT NOT NULL,v$state CHAR(1) NOT NULL, PRIMARY KEY (v$key,v$seq))");
        createSqlMap
                .put("informix",
                        "CREATE TABLE %s (v$key DECIMAL(16,0) NOT NULL,v$key$ varchar(256),v$seq DECIMAL(16,0) NOT NULL,v$state CHAR(1) NOT NULL, PRIMARY KEY (v$key,v$seq))");
        createSqlMap
                .put("oracle",
                        "CREATE TABLE %s (v$key NUMBER(16,0) NOT NULL,v$key$ varchar2(256),v$seq NUMBER(16,0) NOT NULL,v$state CHAR(1) NOT NULL, PRIMARY KEY (v$key,v$seq))");
    }

    static Map<String, String> insertSqlMap = new ConcurrentHashMap<String, String>();
    static {
        insertSqlMap
                .put("h2",
                        "insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',(select ifnull(max(t.v$seq),%d)+%d from %s t where t.v$key=%d),'1')");
        insertSqlMap
                .put("mysql",
                        "insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',(select ifnull(max(t.v$seq),%d)+%d from %s t where t.v$key=%d),'1')");
        insertSqlMap
                .put("informix",
                        "insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',(select nvl(max(t.v$seq),%d)+%d from %s t where t.v$key=%d),'1')");
        insertSqlMap
                .put("oracle",
                        "insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',(select nvl(max(t.v$seq),%d)+%d from %s t where t.v$key=%d),'1')");
    }
    /**
     * 事务模版
     */
    TransactionTemplate transactionTemplate;
    /**
     * 是否使用新事务
     */
    boolean newTransaction = true;
    /**
     * JDBC模版
     */
    JdbcTemplate jdbcTemplate;

    /**
     * 尝试次数(默认10次)
     */
    int tryTime = 10;

    /**
     * 数据库类型
     */
    String databaseType;
    /**
     * 表名
     */
    private String tableName;

    /**
     * 容量
     */
    private int capacity = 25;

    /**
     * 步进
     */
    private int step = 1;
    /**
     * 是否可回收序列号
     */
    protected boolean recyclable;

    @Autowired
    public void setTransactionManager(
            PlatformTransactionManager transactionManager) {
        if (transactionManager != null) {
            transactionTemplate = new TransactionTemplate(transactionManager);
            transactionTemplate
                    .setIsolationLevel(TransactionTemplate.ISOLATION_READ_COMMITTED);
            transactionTemplate
                    .setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
        }
    }

    public boolean isNewTransaction() {
        return newTransaction;
    }

    public void setNewTransaction(boolean newTransaction) {
        this.newTransaction = newTransaction;
    }

    public TransactionTemplate getTransactionTemplate() {
        return transactionTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Autowired
    public void setDataSource(DataSource dataSource) {
        if (jdbcTemplate == null) {
            jdbcTemplate = new JdbcTemplate(dataSource);
        }
    }

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

    public void setTryTime(int tryTime) {
        this.tryTime = tryTime;
    }

    public void setDatabaseType(String databaseType) {
        if (databaseType != null) {
            databaseType = databaseType.trim().toLowerCase();
            this.databaseType = databaseType;
        }
    }

    public void setTableName(String tableName) {
        this.tableName = tableName == null ? null : tableName.trim();
    }

    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }

    public void setStep(int step) {
        this.step = step < 1 ? 1 : step;
    }

    public void setRecyclable(boolean recyclable) {
        this.recyclable = recyclable;
    }

    /**
     * 创建序列
     *
     * @param name
     * @param length
     * @param start
     * @return
     */
    public String generateSequence(String name, int length, long start) {
        final long key = generateKey(name);
        try {
            return generateSequence(key, length, start, name);
        } catch (Throwable t) {
            createSequenceTable();//错误就是定位在这里
            int time = tryTime >= 0 ? tryTime : 10000;
            while (time-- > 0) {
                try {
                    return generateSequence(key, length, start, name);
                } catch (Throwable e) {

                }
            }
            throw new RuntimeException("Generate sequence failure", t);
        }
    }

    private long generateKey(String name) {
        return 10000000000L + name.trim().hashCode();
    }

    /**
     * 创建序列
     *
     * @param key
     * @param length
     * @return
     */
    public String generateSequence(String key, int length) {
        return generateSequence(key, length, 0);
    }

    /**
     * 创建序列
     *
     * @param key
     * @return
     */
    public String generateSequence(String key) {
        return generateSequence(key, 6);
    }

    private synchronized void createSequenceTable() {
        try {
            jdbcTemplate.execute(new ConnectionCallback<Integer>() {

                public Integer doInConnection(Connection connection)
                        throws SQLException, DataAccessException {
                    ResultSet rs = connection.getMetaData().getTables(null,
                            null, tableName, null);
                    try {
                        while (rs.next()) {
                            return 1;
                        }
                    } finally {
                        rs.close();
                    }
                    String createSql = String.format(
                            createSqlMap.get(databaseType), tableName);
                    Statement statement = connection.createStatement();
                    try {
                        statement.execute(createSql);//错误就是定位在这里
                    } finally {
                        statement.close();
                    }
                    return 0;
                }
            });
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }

    private String generateSequence(final long key, final int length,
                                    final long start, final String name) {
        if (newTransaction) {
            try {
                Connection connection = jdbcTemplate.getDataSource()
                        .getConnection();
                try {
                    return atom(connection, new Atom<String>() {

                        @Override
                        public String atom(Connection connection)
                                throws Exception {
                            if (recyclable) {
                                String no = getRecoveredSequence(connection,
                                        key, length);
                                if (no != null) {
                                    return no;
                                }
                            }
                            Statement statement = connection.createStatement();
                            try {
                                String insertSql = String.format(insertSqlMap
                                                .get(databaseType), tableName, key,
                                        name.replace("'", "''"), start < 0 ? 0
                                                : start, step, tableName, key);
                                execute(connection, insertSql);
                                String querySql = String
                                        .format("select max(v$seq) from %s  where v$key=%d and v$state='1'",
                                                tableName, key);
                                ResultSet rs = statement.executeQuery(querySql);
                                try {
                                    while (rs.next()) {
                                        Long max = rs.getLong(1);
                                        if (max < start) {// 重新初始化
                                            String deleteSql = String
                                                    .format("delete from %s where v$key=%d and v$state='1'",
                                                            tableName, key);
                                            execute(connection, deleteSql);
                                            insertSql = String.format(
                                                    insertSqlMap
                                                            .get(databaseType),
                                                    tableName, key,
                                                    name.replace("'", "''"),
                                                    start < 0 ? 0 : start,
                                                    step, tableName, key);
                                            execute(connection, insertSql);
                                            return fillLeftZero(start, length);
                                        }
                                        if (capacity > 0 && max % capacity == 0) {
                                            String deleteSql = String
                                                    .format("delete from %s where v$key=%d and v$seq<>%d and v$state='1'",
                                                            tableName, key, max);
                                            execute(connection, deleteSql);
                                        }
                                        return fillLeftZero(max, length);
                                    }
                                } finally {
                                    rs.close();
                                }
                            } finally {
                                statement.close();
                            }
                            throw new IllegalStateException(
                                    SequenceGenerator.this.getClass()
                                            .getSimpleName()
                                            + "无法获取单号,不可能发生的异常");
                        }
                    });
                } finally {
                    connection.close();
                }
            } catch (Exception e) {
                throw Lang.unchecked(e);
            }
        }
        return getTransactionTemplate().execute(
                new TransactionCallback<String>() {
                    public String doInTransaction(TransactionStatus ts) {
                        try {
                            if (recyclable) {
                                String no = jdbcTemplate
                                        .execute(new ConnectionCallback<String>() {
                                            public String doInConnection(
                                                    Connection connection)
                                                    throws SQLException,
                                                    DataAccessException {
                                                return getRecoveredSequence(
                                                        connection, key, length);
                                            }
                                        });
                                if (no != null) {
                                    return no;
                                }
                            }
                            String insertSql = String.format(insertSqlMap
                                            .get(databaseType), tableName, key, name
                                            .replace("'", "''"), start < 0 ? 0 : start,
                                    step, tableName, key);
                            execute(insertSql);
                            String querySql = String
                                    .format("select max(v$seq) from %s  where v$key=%d and v$state='1'",
                                            tableName, key);
                            Long max = jdbcTemplate.queryForObject(querySql,
                                    Long.class);
                            if (max < start) {// 重新初始化
                                String deleteSql = String
                                        .format("delete from %s where v$key=%d and v$state='1'",
                                                tableName, key);
                                execute(deleteSql);
                                insertSql = String.format(insertSqlMap
                                                .get(databaseType), tableName, key,
                                        name.replace("'", "''"), start < 0 ? 0
                                                : start, step, tableName, key);
                                execute(insertSql);
                                return fillLeftZero(start, length);
                            }
                            if (capacity > 0 && max % capacity == 0) {
                                String deleteSql = String
                                        .format("delete from %s where v$key=%d and v$seq<>%d and v$state='1'",
                                                tableName, key, max);
                                execute(deleteSql);
                            }
                            return fillLeftZero(max, length);
                        } catch (Throwable t) {
                            ts.isRollbackOnly();
                            throw new RuntimeException(t);
                        }
                    }
                });
    }

    /**
     * 参数化执行SQL
     *
     * @param sql
     * @param args
     * @return
     */
    protected int execute(String sql, final Object... args) {
        return jdbcTemplate.execute(sql,
                new PreparedStatementCallback<Integer>() {
                    public Integer doInPreparedStatement(PreparedStatement ps)
                            throws SQLException, DataAccessException {
                        if (args != null) {
                            for (int i = 0; i < args.length; i++) {
                                ps.setObject(i + 1, args[i]);
                            }
                        }
                        return ps.executeUpdate();
                    }
                });
    }

    /**
     * 参数化执行SQL
     *
     * @param sql
     * @param args
     * @return
     * @throws SQLException
     */
    protected int execute(Connection conn, String sql, final Object... args)
            throws SQLException {
        PreparedStatement ps = conn.prepareStatement(sql);
        try {
            if (args != null) {
                for (int i = 0; i < args.length; i++) {
                    ps.setObject(i + 1, args[i]);
                }
            }
            return ps.executeUpdate();
        } finally {
            ps.close();
        }
    }

    protected String fillLeftZero(Long max, int length) {
        StringBuilder sb = new StringBuilder();
        sb.append(max);
        if (sb.length() >= length) {
            return sb.substring(sb.length() - length);
        } else {
            for (int i = sb.length(); i < length; i++) {
                sb.insert(0, '0');
            }
        }
        return sb.toString();
    }

    /**
     * 获取已回收的序列
     *
     * @param connection
     * @param key
     * @throws SQLException
     */
    protected String getRecoveredSequence(Connection connection, long key,
                                          int length) throws SQLException {
        Statement statement = connection.createStatement(
                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
        try {
            String querySql = String
                    .format("select v$key,v$seq,v$state from %s where v$key = %d and v$state<>'1' for update",
                            tableName, key);
            statement.executeQuery(querySql);
            querySql = String
                    .format("select v$key,v$seq,v$state from %s where v$key = %d and v$state<>'1' order by v$seq asc",
                            tableName, key);
            ResultSet rs = statement.executeQuery(querySql);
            try {
                while (rs.next()) {
                    try {
                        Long min = rs.getLong(2);
                        rs.updateString(3, "1");
                        rs.updateRow();
                        return fillLeftZero(min, length);
                    } catch (Throwable ex) {
                    }
                }
            } finally {
                rs.close();
            }
        } finally {
            statement.close();
        }
        return null;
    }

    /**
     * 回收序列号
     *
     * @param name
     * @param sequence
     */
    public void recoveredSequence(final String name, final String sequence) {
        final long key = generateKey(name);
        final long seq = Long.valueOf(sequence);
        if (newTransaction) {
            try {
                Connection connection = jdbcTemplate.getDataSource()
                        .getConnection();
                try {
                    atom(connection, new Atom<Object>() {
                        public Object atom(Connection connection)
                                throws Exception {
                            String updateSql = String
                                    .format("update %s set v$state='0' where v$key=%d and v$seq=%d",
                                            tableName, key, seq);
                            int count = execute(connection, updateSql);
                            if (count == 0) {
                                String insertSql = String
                                        .format("insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',%d,'0')",
                                                tableName, key,
                                                name.replace("'", "''"), seq);
                                execute(connection, insertSql);
                            }
                            return null;
                        }
                    });
                    connection.commit();
                } finally {
                    connection.close();
                }
            } catch (Exception e) {
                throw Lang.unchecked(e);
            }
        } else {
            transactionTemplate.execute(new TransactionCallback<Integer>() {
                public Integer doInTransaction(TransactionStatus status) {
                    try {
                        String updateSql = String
                                .format("update %s set v$state='0' where v$key=%d and v$seq=%d",
                                        tableName, key, seq);
                        int count = execute(updateSql);
                        if (count == 0) {
                            String insertSql = String
                                    .format("insert into %s(v$key,v$key$,v$seq,v$state) values(%d,'%s',%d,'0')",
                                            tableName, key,
                                            name.replace("'", "''"), seq);
                            execute(insertSql);
                        }
                        return null;
                    } catch (Throwable t) {
                        status.isRollbackOnly();
                        throw new RuntimeException(t);
                    }
                }
            });
        }
    }

    public void afterPropertiesSet() throws Exception {
        if (this.databaseType == null) {
            throw new IllegalArgumentException(String.format(
                    "Property '%s' is required", "databaseType"));
        }
        if (databaseType != null) {
            if (!createSqlMap.containsKey(databaseType)) {
                throw new IllegalStateException(String.format(
                        "Unsupported database type:%s", databaseType));
            }
        }
        if (this.jdbcTemplate == null) {
            throw new IllegalArgumentException(String.format(
                    "Property '%s' or '%s' is required", "dataSource",
                    "jdbcTemplate"));
        }
        if (this.tableName == null) {
            throw new IllegalArgumentException(String.format(
                    "Property '%s' is required", "tableName"));
        }
        if (!tableName.matches("[a-zA-Z_][a-zA-Z0-9_]*")
                || tableName.length() > 16) {
            throw new IllegalStateException(String.format(
                    "Illegal tableName:%s", tableName));
        }
        if (!this.newTransaction) {
            if (this.transactionTemplate == null) {
                throw new IllegalArgumentException(String.format(
                        "Property '%s' is required", "transactionManager"));
            }
        }
    }
}

java.lang.RuntimeException: org.springframework.jdbc.BadSqlGrammarException: ConnectionCallback; bad SQL grammar []; nested exception is java.sql.SQLException: ORA-00955: 名称已由现有对象使用

at utils.spring.SequenceGenerator.createSequenceTable(SequenceGenerator.java:272)
at utils.spring.SequenceGenerator.generateSequence(SequenceGenerator.java:202)
at utils.spring.SequenceGenerator.generateSequence(SequenceGenerator.java:227)
at cart.service.service.OrderService.generateOrderNo(OrderService.java:806)
at cart.service.service.OrderService.saveVirtualGoodsToOrder(OrderService.java:220)
at cart.service.service.OrderService$$FastClassBySpringCGLIB$$19f99be7.invoke(<generated>)
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:720)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:655)
at cart.service.service.OrderService$$EnhancerBySpringCGLIB$$feb8eef.saveVirtualGoodsToOrder(<generated>)
at cart.service.apiImpl.OrderMainApiImpl.saveVirtualGoodsToOrder(OrderMainApiImpl.java:223)
at cart.service.apiImpl.OrderMainApiImpl$$FastClassBySpringCGLIB$$fa3518e.invoke(<generated>)
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:651)
at cart.service.apiImpl.OrderMainApiImpl$$EnhancerBySpringCGLIB$$497f044.saveVirtualGoodsToOrder(<generated>)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at com.weibo.api.motan.rpc.DefaultProvider.invoke(DefaultProvider.java:57)
at com.weibo.api.motan.rpc.AbstractProvider.call(AbstractProvider.java:47)
at com.weibo.api.motan.filter.AccessLogFilter.filter(AccessLogFilter.java:56)
at com.weibo.api.motan.protocol.support.ProtocolFilterDecorator$2.call(ProtocolFilterDecorator.java:150)
at utils.rpc.motan.filter.OpenEntityManagerInMotanFilter.filter(OpenEntityManagerInMotanFilter.java:171)
at com.weibo.api.motan.protocol.support.ProtocolFilterDecorator$2.call(ProtocolFilterDecorator.java:150)
at com.weibo.api.motan.transport.ProviderMessageRouter.call(ProviderMessageRouter.java:96)
at com.weibo.api.motan.transport.ProviderProtectedMessageRouter.call(ProviderProtectedMessageRouter.java:79)
at com.weibo.api.motan.transport.ProviderMessageRouter.handle(ProviderMessageRouter.java:91)
at com.weibo.api.motan.transport.support.DefaultRpcHeartbeatFactory$HeartMessageHandleWrapper.handle(DefaultRpcHeartbeatFactory.java:82)
at com.weibo.api.motan.transport.netty.NettyChannelHandler.processRequest(NettyChannelHandler.java:139)
at com.weibo.api.motan.transport.netty.NettyChannelHandler.access$000(NettyChannelHandler.java:47)
at com.weibo.api.motan.transport.netty.NettyChannelHandler$1.run(NettyChannelHandler.java:116)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)

Caused by: org.springframework.jdbc.BadSqlGrammarException: ConnectionCallback; bad SQL grammar []; nested exception is java.sql.SQLException: ORA-00955: 名称已由现有对象使用

at org.springframework.jdbc.support.SQLStateSQLExceptionTranslator.doTranslate(SQLStateSQLExceptionTranslator.java:99)
at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:73)
at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81)
at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81)
at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:360)
at utils.spring.SequenceGenerator.createSequenceTable(SequenceGenerator.java:247)
... 39 more

Caused by: java.sql.SQLException: ORA-00955: 名称已由现有对象使用

at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:112)
at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoer.java:331)
at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoer.java:288)
at oracle.jdbc.driver.T4C8Oall.receive(T4C8Oall.java:745)
at oracle.jdbc.driver.T4CStatement.doOall8(T4CStatement.java:210)
at oracle.jdbc.driver.T4CStatement.executeForRows(T4CStatement.java:961)
at oracle.jdbc.driver.OracleStatement.doExecuteWithTimeout(OracleStatement.java:1190)
at oracle.jdbc.driver.OracleStatement.executeInternal(OracleStatement.java:1726)
at oracle.jdbc.driver.OracleStatement.execute(OracleStatement.java:1696)
at utils.spring.SequenceGenerator$1.doInConnection(SequenceGenerator.java:264)
at utils.spring.SequenceGenerator$1.doInConnection(SequenceGenerator.java:247)
at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:353)
... 40 more

2个回答

建议在去获取序列号的时候加个锁

zy841958835
cloudyzhao 回复Bande_Yi: 如果数据量再大点这样解决就会出现IO阻塞 死锁等问题 需要考虑分布式
接近 3 年之前 回复
github_37982418
Bande_Yi 我仔细查看了代码,发现只是在catch里的方法加了synchronized,而try{}里的方法没有添加,导致生成序列号的时候,操作数据库的过程中出现脏读问题,虽然解决完才看到你的建议,但是确实是最符合我解决方法的建议
接近 3 年之前 回复

这么长,看都不想看了。。。。。。不能精简的说说问题代码是哪块 吗?

github_37982418
Bande_Yi 我在代码中标了,之所以把整个代码都贴出来,因为各处都调用到了
接近 3 年之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
java多线程同时更新和查询数据库并发

java多线程 使用CompletionService提交异步任务,直接上代码 final int count = 1000; public static final ExecutorService executorService = Executors.newFixedThreadPool(3); public void deal(){ CompletionService cs = new ExecutorCompletionService(executorService); for(i=0;i<100;i++){ List<Object> datalist = dao.selectList("select * tableName where state = 0"); cs.submit(datalist) } CountDownLatch latch = new CountDownLatch(100); for(i=0;i<100;i++){ executorService.submit(()->{ dao.updateState(update tableName set state = 1 limit i,1); latch.countDown(); }); } latch.await(); if(count - 100 > 0){ //此处调用的全是和第一次的一模一样 deal(); } } 内层调用获取到的数据全部一模一样,尝试过加读写锁,都不生效,求助

java中什么是高并发和多线程?高并发和多线程有什么关系

高并发和多线程有什么关系吗?访问量一多是不是必须要有多线程来实现?

java多线程并发访问sqlite数据库如何同步和加锁

如题, 使用java语言,sqlite数据如何解决多线程同步锁的问题

现在面试动不动多线程高并发,请问各位大神,你们项目中的多线程高并发是如何用的,哪些场景下用的?

现在面试动不动多线程高并发,请问各位大神,你们项目中的多线程高并发是如何用的,哪些场景下用的?我项目中主要是在做消息推送的时候用到过,消息存到kafka队列里面,然后创建一个线程池创建线程去处理每个消息。就这个地方用到了。其他地方没用到过。都说多线程高并发,听起来很高大上,因为自已没怎么做过这一块,非常好奇,还请大神们多多赐教。谢谢。

Java web项目中的多线程高并发问题怎么解

Java开发购物商城类项目出现多线程高并发怎么处理?求解,感谢。

数据库 高并发 脏读 多线程

问题一 对于项目中一些对数据库的插入操作,每次插入一条两条,但是频繁,是应该没次请求插入数据时就对数据库直接进行插入操作,还是等到了一定的量对数据库进行一次批量操作。还有就是如果想对数据库进行批量操作,那么之前对的那些插入请求往哪里放,就是之前他请求插入,我肯定要把它存起来,然后在一次性插入,就是这个存起来的步骤是怎么处理的,最好用java 问题二 现在库存里只有一千件商品,同时有一万个人下单,下单那部分代码采用了加锁机制,导致了系统很卡,如过不加锁的话,那么可能会出现只有一千件商品,却有五千人下了单,怎么解决

Java多线程并发问题。

``` public class Test { public static void main(String[] args) throws Exception { Executor executor = new Executor(); new Thread(executor::write).start(); new Thread(executor::read).start(); Thread.sleep(500000); } static class Executor { private int MAX_TIMES = 10000; private boolean hasValue = false; void write() { for (int i = 0; i < MAX_TIMES; i++) { while (hasValue) {} System.out.println("Write, " + i); hasValue = true; } } void read() { for (int i = 0; i < MAX_TIMES; i++) { while (!hasValue) {} hasValue = false; System.out.println("Read, " + i); } } } } ``` 我有这么一段代码,原本目的是两个线程交换执行、write线程执行一次,read线程执行一次,但hasValue并不是volatile类型,所以会发生死锁 我有两个问题: 1. 如果读写都是cache line,那为什么不是刚执行就发生死锁,而是执行一会,大概会交替执行100次左右才死锁。 2. 输出结果很奇怪,为什么不是write 0=> read 0 => write 1=>read 1.......这样下去,实际输出结果是这样的 ``` Write, 0 Write, 1 Read, 0 Read, 1 Write, 2 Read, 2 Write, 3 Write, 4 Read, 3 Read, 4 Write, 5 Write, 6 Read, 5 Read, 6 Write, 7 Write, 8 Read, 7 Read, 8 Write, 9 Write, 10 Read, 9 Read, 10 Write, 11 Write, 12 ```

Java多线程并发如何模拟

一个Java Application运行后,在系统中是作为一 个线程吗?运行main方法以后,为什么不能实现多个线程启动?我想用java程序模拟多个消费者和kafka生产者通信,可以实现吗 import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; import org.apache.kafka.clients.consumer.KafkaConsumer; import java.util.Arrays; import java.util.Properties; /** * Created by Administrator on 2016/10/17. */ public class consumerTest extends Thread{ public synchronized void run(){ Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); //消费者组group props.put("group.id", "test"); //是否自动确认offset props.put("enable.auto.commit", "true"); //自动确认offset的时间间隔 props.put("auto.commit.interval.ms", "1000"); //会话超时时间 props.put("session.timeout.ms", "30000"); //key的序列化类 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); //value的序列化类 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props); //消费者订阅的topic, 可同时订阅多个 consumer.subscribe(Arrays.asList("test")); while (true) { //读取数据,读取超时时间为100ms ConsumerRecords<String, String> records = consumer.poll(100); for (ConsumerRecord<String, String> record : records) System.out.println(String.format("offset = %d, key = %s, value = %s", record.offset(), record.key(), record.value())); } } public static void main(String[] args) { consumerTest test1=new consumerTest(); Thread threads[] = new Thread[5]; for (int i = 0; i < threads.length; i++) threads[i] = new Thread(test1); for (int i = 0; i < threads.length; i++) { threads[i].start(); } } }

如何用java单用户多线程查询数据库?

问题是这样的:数据库有14张表相似的表,表属性除了表名都一样(其实就是每个盟市区划都各有一个表),需要通过表查询统计数据并汇总,如果单纯用sql语句再用union all的话需要20多秒的时间,如果数据量再大点这个时间会更长;我现在想通过java多线程同时将14张表的数据查出再进行汇总,至于数据库的I/O方面应该不会有问题,因为可以使用那库的人很少。 我现在可以写出一个多线程的代码如下: [code="java"] public class Test { public static void main(String[] args) throws Exception{ Thread t0 = new MyThread("aa",100); t0.start(); Thread t1 = new MyThread("bb",50); t1.start(); Thread t2 = new MyThread("cc",3); t2.start(); Thread t3 = new MyThread("dd",1); t3.start(); getTotal(); } } [/code] 现在就是无发保证最下面的方法在前面的线程都结束时调用,求解答!

java多线程,并发执行与并行执行的区别是什么?

同一个多线程程序,如果在一个CUP上并发执行与 在多个CPCU上并行执行,从运行结果上有区别吗?(不关心执行效率)

java多线程数据库同步问题

从一个数据库抽取数据 放到自己数据库里面 中间回走数据处理 和判断 用java代码实现目前找到好的方法 多线程操作效率还是很低 一点思路没有 有这方面大神吗

关于java多线程并发读写的问题

1.文件内容读取到缓存 2.从缓存获取文件内容,写入到磁盘 3.控制缓存大小 4.多线程并发写丶读

并发调用oracle存储过程

CREATE OR REPLACE PROCEDURE MAN_ACCOUNT_MRGREDATE_INSERT (v_sellerid in varchar2, v_professtype in varchar2, v_plattype in varchar2, v_margin in varchar2, v_saleamount in varchar2, v_priceamount in varchar2, v_serviceCharge in varchar2, v_creditDate in varchar2, v_refundAmount in varchar2, v_return_code out varchar2) is l_marginid man_act_margin_record.marginid%type; l_count number; --l_sellerid man_act_margin_record.sellerid%type; begin --v_return_code := '0000'; select count(*) into l_count from man_act_margin_record m where m.credit_date = to_date(v_creditDate,'yyyy-MM-dd') and m.sellerid = v_sellerid and m.professtype = v_professtype and m.plattype = v_plattype; --记录已存在,直接返回入库成功 if l_count>0 then delete from man_act_margin_record m where m.credit_date = to_date(v_creditDate,'yyyy-MM-dd') and m.sellerid = v_sellerid and m.professtype = v_professtype and m.plattype = v_plattype; -- 生成主键 select 'M'||to_char(sysdate, 'yymmddhh24miss') || trim(to_char(SEQ_MAN_ACT_MARGIN_RECORD.nextval, '000000')) into l_marginid from dual; insert into man_act_margin_record (marginid, sellerid, professtype, plattype, margin, saleamount, priceamount, service_charge, credit_date, create_date, refund_amount) values (l_marginid, v_sellerid, v_professtype, v_plattype, v_margin, v_saleamount, v_priceamount, v_serviceCharge, to_date(v_creditDate, 'yyyy-MM-dd'), sysdate, v_refundAmount ); v_return_code := '0000'; else -- 生成主键 select 'M'||to_char(sysdate, 'yymmddhh24miss') || trim(to_char(SEQ_MAN_ACT_MARGIN_RECORD.nextval, '000000')) into l_marginid from dual; insert into man_act_margin_record (marginid, sellerid, professtype, plattype, margin, saleamount, priceamount, service_charge, credit_date, create_date, refund_amount) values (l_marginid, v_sellerid, v_professtype, v_plattype, v_margin, v_saleamount, v_priceamount, v_serviceCharge, to_date(v_creditDate, 'yyyy-MM-dd'), sysdate, v_refundAmount ); v_return_code := '0000'; end if; commit; exception when others then v_return_code := '1111'; rollback; raise; end; 我在java代码中并发调用该存储过程,并用log4j打印调用日志,日志显示成功调用2566次,并成功插入到目标表中,但是在oracle实际查询时,数据量却少了100多条,而且每次执行程序,数据量少的数目都不一样。关键是,程序未报异常。 在我的程序中,嵌套两个多线程,第一个是生产者消费者模式(多线程),即同时生产出多个实例,消费者并发,在某个消费者中,又并发多个线程,去调用上面的存储过程。 通过日志初步判断,每个线程都进了存储过程,但是有些并没有执行完存储过程,并返回成功代码'0000',导致了上述的结果。 有oracle大牛,帮忙看看什么问题,不胜感激。

急求,JAVA 多线查询ORACLE线程卡住

因实际查询需要,系统设置40个线程进行数据查询,每个线程查询的时间会很长,都需要几十分钟的查询时间,当查询时间运行到一定的时间后,有些线程就卡在statement.executeQuery(),用jvisuallvm查看线程的执行点停留在java.net.SocketInputStream.socketRead0,再查看ORALCE的V$SESSION,这些线程提交的查询都已执行完成了,TOMCAT日志也没有任何异常记录,各位大神帮帮忙,看下问题会出在哪里。

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

在一个一直运行的类中,由于匹配到特定的任务就需要做特定的事,这个步骤我打算直接在当前类中创建一个线程new Thread().start();做操作,然后通过线程的构造函数把数据库连接对象jdbcTemplate传过去直接查数据库对结果做处理,这样做符号规范吗,或者有没有什么更好的方法

java关于并发查询数据库的问题

java关于并发查询数据库的问题 问题如下 1,从数据库查询2条数据 2,循环2条数据请求第三方接口(耗时)(每条数据只能请求3次第三方接口) 3,请求成功则修改该条数据(请求第三方的次数+1)。 现在的问题是 并发情况下,两个线程同时进来,取到2条数据(已经请求过第三方接口两次) 这时候两个线程同时再去请求第三方接口,得到的结果就只会有一个成功。因为另一个已经达到3次了。 这种问题应该怎么解决???

java 多线程 出现数据重复调用问题

java 多线程 出现数据重复调用问题 用id来判断下是否重复可以啊? 求大神给个实列

java多线程访问sqlite数据库进行读写操作需要用到线程池么?要怎么做?

我看了网上的代码基本都是只写了一个run打印了 ”任务 。。。以完成“ 这样的文字,并没有具体写每个线程所进行的操作啊,求大神指点多线程同时访问sqlite数据库要怎么做?

在中国程序员是青春饭吗?

今年,我也32了 ,为了不给大家误导,咨询了猎头、圈内好友,以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助,记得帮我点赞哦。 目录: 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时,拿着傲人的工资,想着好好干,以为我们的人生是这样的: 等真到了那一天,你会发现,你的人生很可能是这样的: ...

程序员请照顾好自己,周末病魔差点一套带走我。

程序员在一个周末的时间,得了重病,差点当场去世,还好及时挽救回来了。

我以为我学懂了数据结构,直到看了这个导图才发现,我错了

数据结构与算法思维导图

String s = new String(" a ") 到底产生几个对象?

老生常谈的一个梗,到2020了还在争论,你们一天天的,哎哎哎,我不是针对你一个,我是说在座的各位都是人才! 上图红色的这3个箭头,对于通过new产生一个字符串(”宜春”)时,会先去常量池中查找是否已经有了”宜春”对象,如果没有则在常量池中创建一个此字符串对象,然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。 也就是说准确答案是产生了一个或两个对象,如果常量池中原来没有 ”宜春” ,就是两个。...

技术大佬:我去,你写的 switch 语句也太老土了吧

昨天早上通过远程的方式 review 了两名新来同事的代码,大部分代码都写得很漂亮,严谨的同时注释也很到位,这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时,还是忍不住破口大骂:“我擦,小王,你丫写的 switch 语句也太老土了吧!” 来看看小王写的代码吧,看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

Linux面试题(2020最新版)

文章目录Linux 概述什么是LinuxUnix和Linux有什么区别?什么是 Linux 内核?Linux的基本组件是什么?Linux 的体系结构BASH和DOS之间的基本区别是什么?Linux 开机启动过程?Linux系统缺省的运行级别?Linux 使用的进程间通信方式?Linux 有哪些系统日志文件?Linux系统安装多个桌面环境有帮助吗?什么是交换空间?什么是root帐户什么是LILO?什...

将一个接口响应时间从2s优化到 200ms以内的一个案例

一、背景 在开发联调阶段发现一个接口的响应时间特别长,经常超时,囧… 本文讲讲是如何定位到性能瓶颈以及修改的思路,将该接口从 2 s 左右优化到 200ms 以内 。 二、步骤 2.1 定位 定位性能瓶颈有两个思路,一个是通过工具去监控,一个是通过经验去猜想。 2.1.1 工具监控 就工具而言,推荐使用 arthas ,用到的是 trace 命令 具体安装步骤很简单,大家自行研究。 我的使用步骤是...

学历低,无法胜任工作,大佬告诉你应该怎么做

微信上收到一位读者小涛的留言,大致的意思是自己只有高中学历,经过培训后找到了一份工作,但很难胜任,考虑要不要辞职找一份他能力可以胜任的实习工作。下面是他留言的一部分内容: 二哥,我是 2016 年高中毕业的,考上了大学但没去成,主要是因为当时家里经济条件不太允许。 打工了三年后想学一门技术,就去培训了。培训的学校比较垃圾,现在非常后悔没去正规一点的机构培训。 去年 11 月份来北京找到了一份工...

JVM内存结构和Java内存模型别再傻傻分不清了

JVM内存结构和Java内存模型都是面试的热点问题,名字看感觉都差不多,网上有些博客也都把这两个概念混着用,实际上他们之间差别还是挺大的。 通俗点说,JVM内存结构是与JVM的内部存储结构相关,而Java内存模型是与多线程编程相关,本文针对这两个总是被混用的概念展开讲解。 JVM内存结构 JVM构成 说到JVM内存结构,就不会只是说内存结构的5个分区,而是会延展到整个JVM相关的问题,所以先了解下

和黑客斗争的 6 天!

互联网公司工作,很难避免不和黑客们打交道,我呆过的两家互联网公司,几乎每月每天每分钟都有黑客在公司网站上扫描。有的是寻找 Sql 注入的缺口,有的是寻找线上服务器可能存在的漏洞,大部分都...

Google 与微软的浏览器之争

浏览器再现“神仙打架”。整理 | 屠敏头图 | CSDN 下载自东方 IC出品 | CSDN(ID:CSDNnews)从 IE 到 Chrome,再从 Chrome 到 Edge,微软与...

讲一个程序员如何副业月赚三万的真实故事

loonggg读完需要3分钟速读仅需 1 分钟大家好,我是你们的校长。我之前讲过,这年头,只要肯动脑,肯行动,程序员凭借自己的技术,赚钱的方式还是有很多种的。仅仅靠在公司出卖自己的劳动时...

上班一个月,后悔当初着急入职的选择了

最近有个老铁,告诉我说,上班一个月,后悔当初着急入职现在公司了。他之前在美图做手机研发,今年美图那边今年也有一波组织优化调整,他是其中一个,在协商离职后,当时捉急找工作上班,因为有房贷供着,不能没有收入来源。所以匆忙选了一家公司,实际上是一个大型外包公司,主要派遣给其他手机厂商做外包项目。**当时承诺待遇还不错,所以就立马入职去上班了。但是后面入职后,发现薪酬待遇这块并不是HR所说那样,那个HR自...

女程序员,为什么比男程序员少???

昨天看到一档综艺节目,讨论了两个话题:(1)中国学生的数学成绩,平均下来看,会比国外好?为什么?(2)男生的数学成绩,平均下来看,会比女生好?为什么?同时,我又联想到了一个技术圈经常讨...

搜狗输入法也在挑战国人的智商!

故事总是一个接着一个到来...上周写完《鲁大师已经彻底沦为一款垃圾流氓软件!》这篇文章之后,鲁大师的市场工作人员就找到了我,希望把这篇文章删除掉。经过一番沟通我先把这篇文章从公号中删除了...

85后蒋凡:28岁实现财务自由、34岁成为阿里万亿电商帝国双掌门,他的人生底层逻辑是什么?...

蒋凡是何许人也? 2017年12月27日,在入职4年时间里,蒋凡开挂般坐上了淘宝总裁位置。 为此,时任阿里CEO张勇在任命书中力赞: 蒋凡加入阿里,始终保持创业者的冲劲,有敏锐的...

总结了 150 余个神奇网站,你不来瞅瞅吗?

原博客再更新,可能就没了,之后将持续更新本篇博客。

副业收入是我做程序媛的3倍,工作外的B面人生是怎样的?

提到“程序员”,多数人脑海里首先想到的大约是:为人木讷、薪水超高、工作枯燥…… 然而,当离开工作岗位,撕去层层标签,脱下“程序员”这身外套,有的人生动又有趣,马上展现出了完全不同的A/B面人生! 不论是简单的爱好,还是正经的副业,他们都干得同样出色。偶尔,还能和程序员的特质结合,产生奇妙的“化学反应”。 @Charlotte:平日素颜示人,周末美妆博主 大家都以为程序媛也个个不修边幅,但我们也许...

MySQL数据库面试题(2020最新版)

文章目录数据库基础知识为什么要使用数据库什么是SQL?什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式?分别有什么区别?数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别?InnoDB引擎的4大特性存储引擎选择索引什么是索引?索引有哪些优缺点?索引使用场景(重点)...

如果你是老板,你会不会踢了这样的员工?

有个好朋友ZS,是技术总监,昨天问我:“有一个老下属,跟了我很多年,做事勤勤恳恳,主动性也很好。但随着公司的发展,他的进步速度,跟不上团队的步伐了,有点...

我入职阿里后,才知道原来简历这么写

私下里,有不少读者问我:“二哥,如何才能写出一份专业的技术简历呢?我总感觉自己写的简历太烂了,所以投了无数份,都石沉大海了。”说实话,我自己好多年没有写过简历了,但我认识的一个同行,他在阿里,给我说了一些他当年写简历的方法论,我感觉太牛逼了,实在是忍不住,就分享了出来,希望能够帮助到你。 01、简历的本质 作为简历的撰写者,你必须要搞清楚一点,简历的本质是什么,它就是为了来销售你的价值主张的。往深...

离职半年了,老东家又发 offer,回不回?

有小伙伴问松哥这个问题,他在上海某公司,在离职了几个月后,前公司的领导联系到他,希望他能够返聘回去,他很纠结要不要回去? 俗话说好马不吃回头草,但是这个小伙伴既然感到纠结了,我觉得至少说明了两个问题:1.曾经的公司还不错;2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说,松哥之前也有过类似的经历,今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点,就是离职了也没必要和老东家弄的苦...

男生更看重女生的身材脸蛋,还是思想?

往往,我们看不进去大段大段的逻辑。深刻的哲理,往往短而精悍,一阵见血。问:产品经理挺漂亮的,有点心动,但不知道合不合得来。男生更看重女生的身材脸蛋,还是...

什么时候跳槽,为什么离职,你想好了么?

都是出来打工的,多为自己着想

程序员为什么千万不要瞎努力?

本文作者用对比非常鲜明的两个开发团队的故事,讲解了敏捷开发之道 —— 如果你的团队缺乏统一标准的环境,那么即使勤劳努力,不仅会极其耗时而且成果甚微,使用...

为什么程序员做外包会被瞧不起?

二哥,有个事想询问下您的意见,您觉得应届生值得去外包吗?公司虽然挺大的,中xx,但待遇感觉挺低,马上要报到,挺纠结的。

当HR压你价,说你只值7K,你该怎么回答?

当HR压你价,说你只值7K时,你可以流畅地回答,记住,是流畅,不能犹豫。 礼貌地说:“7K是吗?了解了。嗯~其实我对贵司的面试官印象很好。只不过,现在我的手头上已经有一份11K的offer。来面试,主要也是自己对贵司挺有兴趣的,所以过来看看……”(未完) 这段话主要是陪HR互诈的同时,从公司兴趣,公司职员印象上,都给予对方正面的肯定,既能提升HR的好感度,又能让谈判气氛融洽,为后面的发挥留足空间。...

面试:第十六章:Java中级开发(16k)

HashMap底层实现原理,红黑树,B+树,B树的结构原理 Spring的AOP和IOC是什么?它们常见的使用场景有哪些?Spring事务,事务的属性,传播行为,数据库隔离级别 Spring和SpringMVC,MyBatis以及SpringBoot的注解分别有哪些?SpringMVC的工作原理,SpringBoot框架的优点,MyBatis框架的优点 SpringCould组件有哪些,他们...

面试阿里p7,被按在地上摩擦,鬼知道我经历了什么?

面试阿里p7被问到的问题(当时我只知道第一个):@Conditional是做什么的?@Conditional多个条件是什么逻辑关系?条件判断在什么时候执...

终于懂了TCP和UDP协议区别

终于懂了TCP和UDP协议区别

无代码时代来临,程序员如何保住饭碗?

编程语言层出不穷,从最初的机器语言到如今2500种以上的高级语言,程序员们大呼“学到头秃”。程序员一边面临编程语言不断推陈出新,一边面临由于许多代码已存在,程序员编写新应用程序时存在重复“搬砖”的现象。 无代码/低代码编程应运而生。无代码/低代码是一种创建应用的方法,它可以让开发者使用最少的编码知识来快速开发应用程序。开发者通过图形界面中,可视化建模来组装和配置应用程序。这样一来,开发者直...

立即提问
相关内容推荐