乐观锁解决高并发

时间  2019-11-18
标签 乐观 解决 并发 繁體版
原文   原文链接

根本决解办法只有一个：队列，下面说的没有用的html

对于咱们开发的网站，若是网站的访问量很是大的话，那么咱们就须要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题，java

但话又说回来了，既然逃避不掉，那咱们就坦然面对吧~今天就让咱们一块儿来研究一下常见的并发和同步吧。mysql

   为了更好的理解并发和同步，咱们须要先明白两个重要的概念:同步和异步nginx

   一、同步和异步的区别和联系程序员

         所谓同步，能够理解为在执行完一个函数或方法以后，一直等待系统返回值或消息，这时程序是出于阻塞的，只有接收到web

        返回的值或消息后才往下执行其它的命令。sql

        异步，执行完函数或方法后，没必要阻塞性地等待返回值或消息，只须要向系统委托一个异步过程，那么当系统接收到返回数据库

        值或消息时，系统会自动触发委托的异步过程，从而完成一个完整的流程。apache

         同步在必定程度上能够看作是单线程，这个线程请求一个方法后就待这个方法给他回复，不然他不往下执行(死心眼)。缓存

        异步在必定程度上能够看作是多线程的(废话，一个线程怎么叫异步)，请求一个方法后，就无论了，继续执行其余的方法。

        

        同步就是一件事，一件事情一件事的作。
        异步就是，作一件事情，不引响作其余事情。

        例如：吃饭和说话，只能一件事一件事的来，由于只有一张嘴。
                但吃饭和听音乐是异步的，由于，听音乐并不引响咱们吃饭。

 

        对于Java程序员而言，咱们会常常听到同步关键字synchronized，假如这个同步的监视对象是类的话，那么若是当一个对象

        访问类里面的同步方法的话，那么其它的对象若是想要继续访问类里面的这个同步方法的话，就会进入阻塞，只有等前一个对象

        执行完该同步方法后当前对象才可以继续执行该方法。这就是同步。相反，若是方法前没有同步关键字修饰的话，那么不一样的对象

        能够在同一时间访问同一个方法，这就是异步。

      

        在补充一下(脏数据和不可重复读的相关概念):

       脏数据

　　 脏读就是指当一个事务正在访问数据，而且对数据进行了修改，而这种修改尚未提交到数据库中，这时，另一个事务也访问这个数据，而后使用了这
个数据。由于这个数据是尚未提交的数据，那么另一个事务读到的这个数据是脏数据(Dirty Data)，依据脏数据所作的操做多是不正确的。

     不可重复读

　　 不可重复读是指在一个事务内，屡次 读同一数据。在这个事务尚未结束时，另一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，因为第二个事务的修改，那么第一个事务两次 读到的数据多是不同的。这样就发生了在一个事务内两次读到的数据是不同的，所以称为是不可重复读

 

         

 

   二、如何处理并发和同步

        今天讲的如何处理并发和同同步问题主要是经过锁机制。

       咱们须要明白，锁机制有两个层面。

       一种是代码层次上的，如java中的同步锁，典型的就是同步关键字synchronized，这里我不在作过多的讲解，

       感兴趣的能够参考:http://www.cnblogs.com/xiohao/p/4151408.html

       另一种是数据库层次上的，比较典型的就是悲观锁和乐观锁。这里咱们重点讲解的就是悲观锁（传统的物理锁）和乐观锁。

       悲观锁(Pessimistic Locking):       

       悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其余事务，以及来自 外部系统的事务处理）修改持保守态度，所以，

       在整个数据处理过程当中，将数据处于锁定状态。

       悲观锁的实现，每每依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能 真正保证数据访问的排他性，不然，即便在本系统

       中实现了加锁机制，也没法保证外部系 统不会修改数据）。 

       一个典型的倚赖数据库的悲观锁调用： 

       select * from account where name=”Erica” for update

       这条 sql 语句锁定了 account 表中全部符合检索条件（ name=”Erica” ）的记录。

       本次事务提交以前（事务提交时会释放事务过程当中的锁），外界没法修改这些记录。
       Hibernate 的悲观锁，也是基于数据库的锁机制实现。
       下面的代码实现了对查询记录的加锁：

       String hqlStr ="from TUser as user where user.name='Erica'";

        Query query = session.createQuery(hqlStr);

        query.setLockMode("user",LockMode.UPGRADE); // 加锁

       List userList = query.list();// 执行查询，获取数据

       query.setLockMode 对查询语句中，特定别名所对应的记录进行加锁（咱们为 TUser 类指定了一个别名 “user” ），这里也就是对

      返回的全部 user 记录进行加锁。 

      观察运行期 Hibernate 生成的 SQL 语句：
      select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id
      as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex
      from t_user tuser0_ where (tuser0_.name='Erica' ) for update
     这里 Hibernate 经过使用数据库的 for update 子句实现了悲观锁机制。
      Hibernate 的加锁模式有：
      Ø LockMode.NONE ： 无锁机制。
      Ø LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动获取
      Ø LockMode.READ ： Hibernate 在读取记录的时候会自动获取。
      以上这三种锁机制通常由 Hibernate 内部使用，如 Hibernate 为了保证 Update
      过程当中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。
      Ø LockMode.UPGRADE ：利用数据库的 for update 子句加锁。
      Ø LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 for
      update nowait 子句实现加锁。
      上面这两种锁机制是咱们在应用层较为经常使用的，加锁通常经过如下方法实现：
      Criteria.setLockMode
      Query.setLockMode
      Session.lock
      注意，只有在查询开始以前（也就是 Hiberate 生成 SQL 以前）设定加锁，才会
      真正经过数据库的锁机制进行加锁处理，不然，数据已经经过不包含 for update
      子句的 Select SQL 加载进来，所谓数据库加锁也就无从谈起。

      为了更好的理解select... for update的锁表的过程，本人将要以mysql为例，进行相应的讲解

      一、要测试锁定的情况，能够利用MySQL的Command Mode ，开二个视窗来作测试。

          表的基本结构以下:

          

 

           表中内容以下:

           

 

          开启两个测试窗口，在其中一个窗口执行select * from ta for update0

          而后在另一个窗口执行update操做以下图:

          

          等到一个窗口commit后的图片以下:

          

           到这里，悲观锁机制你应该了解一些了吧~

       

           须要注意的是for update要放到mysql的事务中，即begin和commit中，否者不起做用。

           至因而锁住整个表仍是锁住选中的行，请参考:

           http://www.cnblogs.com/xiohao/p/4385768.html

            至于hibernate中的悲观锁使用起来比较简单，这里就不写demo了~感兴趣的本身查一下就ok了~

           

          乐观锁(Optimistic Locking):        
         相对悲观锁而言，乐观锁机制采起了更加宽松的加锁机制。悲观锁大多数状况下依 靠数据库的锁机制实现，以保证操做最大程度的独占性。但随之

而来的就是数据库 性能的大量开销，特别是对长事务而言，这样的开销每每没法承受。 如一个金融系统，当某个操做员读取用户的数据，并在读出的用户数

据的基础上进 行修改时（如更改用户账户余额），若是采用悲观锁机制，也就意味着整个操做过 程中（从操做员读出数据、开始修改直至提交修改结果的全

过程，甚至还包括操做 员中途去煮咖啡的时间），数据库记录始终处于加锁状态，能够想见，若是面对几 百上千个并发，这样的状况将致使怎样的后果。 乐

观锁机制在必定程度上解决了这个问题。

         乐观锁，大可能是基于数据版本   Version ）记录机制实现。何谓数据版本？即为数据增长一个版本标识，在基于数据库表的版本解决方案中，通常是通

过为数据库表增长一个 “version” 字段来 实现。 读取出数据时，将此版本号一同读出，以后更新时，对此版本号加一。此时，将提 交数据的版本数据与数据

库表对应记录的当前版本信息进行比对，若是提交的数据 版本号大于数据库表当前版本号，则予以更新，不然认为是过时数据。 对于上面修改用户账户信息

的例子而言，假设数据库中账户信息表中有一个 version 字段，当前值为 1 ；而当前账户余额字段（ balance ）为 $100 。 操做员 A 此时将其读出

（ version=1 ），并从其账户余额中扣除 $50（ $100-$50 ）。 2 在操做员 A 操做的过程当中，操做员 B 也读入此用户信息（ version=1 ），并 从其账

户余额中扣除 $20 （ $100-$20 ）。 3 操做员 A 完成了修改工做，将数据版本号加一（ version=2 ），连同账户扣 除后余额（ balance=$50 ），提交

至数据库更新，此时因为提交数据版本大 于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。 4 操做员 B 完成了操做，也将版本号加一

（ version=2 ）试图向数据库提交数 据（ balance=$80 ），但此时比对数据库记录版本时发现，操做员 B 提交的 数据版本号为 2 ，数据库记录当前版

本也为 2 ，不知足 “ 提交版本必须大于记 录当前版本才能执行更新 “ 的乐观锁策略，所以，操做员 B 的提交被驳回。 这样，就避免了操做员 B 用基于

version=1 的旧数据修改的结果覆盖操做 员 A 的操做结果的可能。 从上面的例子能够看出，乐观锁机制避免了长事务中的数据库加锁开销（操做员 A


和操做员 B 操做过程当中，都没有对数据库数据加锁），大大提高了大并发量下的系 统总体性能表现。 须要注意的是，乐观锁机制每每基于系统中的数据存储

逻辑，所以也具有必定的局 限性，如在上例中，因为乐观锁机制是在咱们的系统中实现，来自外部系统的用户 余额更新操做不受咱们系统的控制，所以可能

会形成脏数据被更新到数据库中。在 系统设计阶段，咱们应该充分考虑到这些状况出现的可能性，并进行相应调整（如 将乐观锁策略在数据库存储过程当中实

现，对外只开放基于此存储过程的数据更新途 径，而不是将数据库表直接对外公开）。 Hibernate 在其数据访问引擎中内置了乐观锁实现。若是不用考虑外

部系统对数 据库的更新操做，利用 Hibernate 提供的透明化乐观锁实现，将大大提高咱们的 生产力。


Hibernate 中能够经过 class 描述符的 optimistic-lock 属性结合 version描述符指定。

如今，咱们为以前示例中的 User 加上乐观锁机制。

 

1 ． 首先为 User 的POJO class

       

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.xiaohao.test;
 
public class User {
    private Integer id;
    private String userName;
    private String password;
    private int version;
    
public int getVersion() {
     return version;
}
 
public void setVersion( int version) {
     this .version = version;
}
 
public Integer getId() {
     return id;
}
 
public void setId(Integer id) {
     this .id = id;
}
 
public String getUserName() {
     return userName;
}
 
public void setUserName(String userName) {
     this .userName = userName;
}
 
public String getPassword() {
     return password;
}
 
public void setPassword(String password) {
     this .password = password;
}
 
 
 
public User() {}
 
public User(String userName, String password) {
     super ();
     this .userName = userName;
     this .password = password;
}
 
 
    
    
}

　　


        而后是User.hbm.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version= "1.0" ?>
<!DOCTYPE hibernate-mapping PUBLIC
         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
 
<hibernate-mapping package = "com.xiaohao.test" >
 
     < class name= "User"  table= "user" optimistic-lock= "version" >
               <id name= "id" >
             <generator class = "native" />
         </id>
         <!--version标签必须跟在id标签后面-->
         <version column= "version" name= "version"  />
         <property name= "userName" />
         <property name= "password" />
                 
     </ class >
     
 
</hibernate-mapping>

注意 version 节点必须出如今 ID 节点以后。
这里咱们声明了一个 version 属性，用于存放用户的版本信息，保存在 User 表的version中
optimistic-lock 属性有以下可选取值：
Ø none
无乐观锁
Ø version
经过版本机制实现乐观锁
Ø dirty
经过检查发生变更过的属性实现乐观锁
Ø all
经过检查全部属性实现乐观锁
其中经过 version 实现的乐观锁机制是 Hibernate 官方推荐的乐观锁实现，同时也
是 Hibernate 中，目前惟一在数据对象脱离 Session 发生修改的状况下依然有效的锁机
制。所以，通常状况下，咱们都选择 version 方式做为 Hibernate 乐观锁实现机制。


2 ． 配置文件hibernate.cfg.xml和UserTest测试类

   hibernate.cfg.xml

  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >
 
<hibernate-configuration>
<session-factory>
 
     <!-- 指定数据库方言 若是使用jbpm的话，数据库方言只能是InnoDB-->
     <property name= "dialect" >org.hibernate.dialect.MySQL5InnoDBDialect</property>
     <!-- 根据须要自动建立数据表 -->
     <property name= "hbm2ddl.auto" >update</property>
     <!-- 显示Hibernate持久化操做所生成的SQL -->
     <property name= "show_sql" > true </property>
     <!-- 将SQL脚本进行格式化后再输出 -->
     <property name= "format_sql" > false </property>
     <property name= "current_session_context_class" >thread</property>
 
 
     <!-- 导入映射配置 -->
     <property name= "connection.url" >jdbc:mysql: ///user</property>
     <property name= "connection.username" >root</property>
     <property name= "connection.password" > 123456 </property>
     <property name= "connection.driver_class" >com.mysql.jdbc.Driver</property>
     <mapping resource= "com/xiaohao/test/User.hbm.xml" />
 
 
 
</session-factory>
</hibernate-configuration>

　　UserTest.java

    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.xiaohao.test;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
 
public class UserTest {
     public static void main(String[] args) {
         Configuration conf= new Configuration().configure();
         SessionFactory sf=conf.buildSessionFactory();
         Session session=sf.getCurrentSession();
         Transaction tx=session.beginTransaction();
//      User user=new User("小浩","英雄");
//      session.save(user);
//       session.createSQLQuery("insert into user(userName,password) value('张英雄16','123')")
//                  .executeUpdate();
         User user=(User) session.get(User. class , 1 );
         user.setUserName( "221" );
//      session.save(user);
     
         System.out.println( "恭喜您，用户的数据插入成功了哦~~" );
         tx.commit();
     }
 
}

　　每次对 TUser 进行更新的时候，咱们能够发现，数据库中的 version 都在递增。



下面咱们将要经过乐观锁来实现一下并发和同步的测试用例:

这里须要使用两个测试类，分别运行在不一样的虚拟机上面，以此来模拟多个用户同时操做一张表,同时其中一个测试类须要模拟长事务

UserTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.xiaohao.test;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
 
public class UserTest {
     public static void main(String[] args) {
         Configuration conf= new Configuration().configure();
         SessionFactory sf=conf.buildSessionFactory();
         Session session=sf.openSession();
//      Session session2=sf.openSession();
         User user=(User) session.createQuery( " from User user where user=5" ).uniqueResult();
//      User user2=(User) session.createQuery(" from User user where user=5").uniqueResult();
         System.out.println(user.getVersion());
//      System.out.println(user2.getVersion());
         Transaction tx=session.beginTransaction();
         user.setUserName( "101" );
         tx.commit();
         
         System.out.println(user.getVersion());
//      System.out.println(user2.getVersion());
//      System.out.println(user.getVersion()==user2.getVersion());
//      Transaction tx2=session2.beginTransaction();
//      user2.setUserName("4468");
//      tx2.commit();
     
     }
 
}

　　UserTest2.java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.xiaohao.test;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
 
public class UserTest2 {
     public static void main(String[] args) throws InterruptedException {
         Configuration conf= new Configuration().configure();
         SessionFactory sf=conf.buildSessionFactory();
         Session session=sf.openSession();
//      Session session2=sf.openSession();
         User user=(User) session.createQuery( " from User user where user=5" ).uniqueResult();
         Thread.sleep( 10000 );
//      User user2=(User) session.createQuery(" from User user where user=5").uniqueResult();
         System.out.println(user.getVersion());
//      System.out.println(user2.getVersion());
         Transaction tx=session.beginTransaction();
         user.setUserName( "100" );
         tx.commit();
         
         System.out.println(user.getVersion());
//      System.out.println(user2.getVersion());
//      System.out.println(user.getVersion()==user2.getVersion());
//      Transaction tx2=session2.beginTransaction();
//      user2.setUserName("4468");
//      tx2.commit();
     
     }
 
}

 

操做流程及简单讲解: 首先启动UserTest2.java测试类，在执行到Thread.sleep(10000);这条语句的时候，当前线程会进入睡眠状态。在10秒钟以内

                            启动UserTest这个类，在到达10秒的时候，咱们将会在UserTest.java中抛出下面的异常:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Exception in thread "main" org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [com.xiaohao.test.User# 5 ]
     at org.hibernate.persister.entity.AbstractEntityPersister.check(AbstractEntityPersister.java: 1932 )
     at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java: 2576 )
     at org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java: 2476 )
     at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java: 2803 )
     at org.hibernate.action.EntityUpdateAction.execute(EntityUpdateAction.java: 113 )
     at org.hibernate.engine.ActionQueue.execute(ActionQueue.java: 273 )
     at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java: 265 )
     at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java: 185 )
     at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java: 321 )
     at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java: 51 )
     at org.hibernate.impl.SessionImpl.flush(SessionImpl.java: 1216 )
     at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java: 383 )
     at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java: 133 )
     at com.xiaohao.test.UserTest2.main(UserTest2.java: 21 )

 

 UserTest2代码将在 tx.commit() 处抛出 StaleObjectStateException 异 常，并指出版本检查失败，当前事务正在试图提交一个过时数据。经过捕捉这个异常，我 们就能够在乐观锁校验失败时进行相应处理

 

 

 

   三、常见并发同步案例分析

    案例一:订票系统案例，某航班只有一张机票，假定有1w我的打开你的网站来订票，问你如何解决并发问题(可扩展到任何高并发网站要考虑

               的并发读写问题)

    问题，1w我的来访问，票没出去前要保证你们都能看到有票，不可能一我的在看到票的时候别人就不能看了。到底谁能抢到，那得看这我的的“运气”（网

             络快慢等）

其次考虑的问题，并发，1w我的同时点击购买，到底谁能成交？总共只有一张票。

首先咱们容易想到和并发相关的几个方案 ：

锁同步同步更多指的是应用程序的层面，多个线程进来，只能一个一个的访问，java中指的是syncrinized关键字。锁也有2个层面，一个是java中谈到的对

象锁，用于线程同步；另一个层面是数据库的锁；若是是分布式的系统，显然只能利用数据库端的锁来实现。

假定咱们采用了同步机制或者数据库物理锁机制，如何保证1w我的还能同时看到有票，显然会牺牲性能，在高并发网站中是不可取的。使用hibernate后咱们

提出了另一个概念：乐观锁、悲观锁（即传统的物理锁）；

采用乐观锁便可解决此问题。乐观锁意思是不锁定表的状况下，利用业务的控制来解决并发问题，这样即保证数据的并发可读性又保证保存数据的排他性，保

证性能的同时解决了并发带来的脏数据问题。

hibernate中如何实现乐观锁：

前提：在现有表当中增长一个冗余字段，version版本号, long类型

原理：

1）只有当前版本号》=数据库表版本号，才能提交

2）提交成功后，版本号version ++

实现很简单：在ormapping增长一属性optimistic-lock="version"便可，如下是样例片断

<hibernate-mapping>

<class name="com.insigma.stock.ABC" optimistic-lock="version" table="T_Stock" schema="STOCK">

案例2、股票交易系统、银行系统，大数据量你是如何考虑的

首先，股票交易系统的行情表，每几秒钟就有一个行情记录产生，一天下来就有（假定行情3秒一个） 股票数量×20×60*6 条记录，一月下来这个表记录数

量多大？ oracle中一张表的记录数超过100w后 查询性能就不好了，如何保证系统性能？

再好比，中国移动有上亿的用户量，表如何设计？把全部用于存在于一个表么？

因此，大数量的系统，必须考虑表拆分-（表名字不同，可是结构彻底同样），通用的几种方式：（视状况而定）

1）按业务分，好比 手机号的表，咱们能够考虑 130开头的做为一个表，131开头的另一张表 以此类推

2）利用oracle的表拆分机制作分表

3）若是是交易系统，咱们能够考虑按时间轴拆分，当日数据一个表，历史数据弄到其它表。这里历史数据的报表和查询不会影响当日交易。

固然，表拆分后咱们的应用得作相应的适配。单纯的or-mapping也许就得改动了。好比部分业务得经过存储过程等

此外，咱们还得考虑缓存

这里的缓存，指的不只仅是hibernate，hibernate自己提供了一级二级缓存。这里的缓存独立于应用，依然是内存的读取，假如咱们能减小数据库频繁的访

问，那对系统确定大大有利的。好比一个电子商务系统的商品搜索，若是某个关键字的商品常常被搜，那就能够考虑这部分商品列表存放到缓存（内存中

去），这样不用每次访问数据库，性能大大增长。

简单的缓存你们能够理解为本身作一个hashmap，把常访问的数据作一个key，value是第一次从数据库搜索出来的值，下次访问就能够从map里读取，而不

读数据库；专业些的目前有独立的缓存框架好比memcached 等，可独立部署成一个缓存服务器。

 

四、常见的提升高并发下访问的效率的手段

      首先要了解高并发的的瓶颈在哪里？

     一、多是服务器网络带宽不够

     2.可能web线程链接数不够

     3.可能数据库链接查询上不去。

     根据不一样的状况，解决思路也不一样。

  1. 像第一种状况能够增长网络带宽，DNS域名解析分发多台服务器。

  2. 负载均衡，前置代理服务器nginx、apache等等

  3. 数据库查询优化，读写分离，分表等等

   最后复制一些在高并发下面须要经常须要处理的内容:

  • 尽可能使用缓存，包括用户缓存，信息缓存等，多花点内存来作缓存，能够大量减小与数据库的交互，提升性能。

  • 用jprofiler等工具找出性能瓶颈，减小额外的开销。

  • 优化数据库查询语句，减小直接使用hibernate等工具的直接生成语句（仅耗时较长的查询作优化）。

  • 优化数据库结构，多作索引，提升查询效率。

  • 统计的功能尽可能作缓存，或按天天一统计或定时统计相关报表，避免须要时进行统计的功能。

  • 能使用静态页面的地方尽可能使用，减小容器的解析（尽可能将动态内容生成静态html来显示）。

  • 解决以上问题后，使用服务器集群来解决单台的瓶颈问题。

 

好吧，简单的高并发和同步就到这里吧~~

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程