Exemples de solutions à haute concurrence et d'optimisation de charge élevée en Java

Un petit site Web, tel qu'un site Web personnel, peut être réalisé en utilisant la page statique HTML la plus simple, avec quelques images pour obtenir un effet embellissant. Toutes les pages sont stockées dans un répertoire. Un tel site Web a un grand impact sur le système. architecture et performances. Les exigences sont très simples. Avec l'enrichissement continu des activités Internet, les technologies liées aux sites Web ont été subdivisées en aspects très fins après des années de développement. Surtout pour les grands sites Web, les technologies utilisées sont très variées. Les logiciels, langages de programmation, bases de données, serveurs Web, pare-feu et autres domaines sont soumis à des exigences très élevées qui ne sont plus comparables au simple site Web statique HTML d'origine.

Grands sites Web, tels que des portails. Face à un grand nombre d'accès utilisateurs et à des demandes simultanées élevées, les solutions de base se concentrent sur les liens suivants : utilisation de serveurs hautes performances, de bases de données hautes performances, de langages de programmation hautes performances et de conteneurs Web hautes performances. Mais en dehors de ces aspects, il n’existe pas de solution fondamentale aux problèmes de charge élevée et de concurrence élevée auxquels sont confrontés les grands sites Web.

Les différentes idées de solutions fournies ci-dessus signifient également un investissement plus important dans une certaine mesure, et ces idées de solutions présentent des goulots d'étranglement et n'ont pas une bonne évolutivité. Ci-dessous, je commencerai par un faible coût, des performances élevées et des performances élevées. certaines de mes expériences dans une perspective d'expansion.

1. HTML statique

En fait, tout le monde sait que la plus efficace et la moins consommée est la page html purement statique, nous faisons donc de notre mieux pour réaliser notre site internet. Les pages sont implémentées à l'aide de pages statiques. Cette méthode la plus simple est en fait la méthode la plus efficace. Cependant, pour les sites Web avec une grande quantité de contenu et des mises à jour fréquentes, nous ne pouvons pas tous les mettre en œuvre manuellement un par un, c'est pourquoi notre système commun de publication d'informations CMS est apparu, comme les chaînes d'information des différents sites portails que nous visitons souvent, et même leurs autres canaux, tout au long de Il est géré et mis en œuvre par le système de diffusion d'informations. Le système de diffusion d'informations peut réaliser la saisie d'informations la plus simple et générer automatiquement des pages statiques. Il peut également avoir des fonctions telles que la gestion des canaux, la gestion des autorisations, l'exploration automatique, etc. un grand site Web, il dispose d'un CMS efficace et gérable est essentiel.

En plus des portails et des sites de publication d'informations, pour les sites de type communautaire avec des exigences d'interactivité élevées, être le plus statique possible est également un moyen nécessaire pour améliorer les performances des posts et articles de la communauté pouvant être traités en réel. La statique, puis la re-staticisation en cas de mise à jour, sont également une stratégie largement utilisée. Le méli-mélo de Mop utilise cette stratégie, tout comme la communauté NetEase, etc.

Dans le même temps, le HTML statique est également un moyen utilisé par certaines stratégies de mise en cache. Pour les applications du système qui utilisent fréquemment des requêtes de base de données mais qui ont de très petites mises à jour de contenu, vous pouvez envisager d'utiliser le HTML statique pour y parvenir, Comme les forums publics dans les forums. Informations de configuration, ces informations peuvent être gérées par les forums grand public actuels et stockées dans la base de données. En fait, une grande partie de ces informations sont appelées par le programme frontal, mais la fréquence de mise à jour est très. small. Vous pouvez envisager de rendre cette partie du contenu statique lors de la mise à jour de l'arrière-plan. Cela évite un grand nombre de demandes d'accès à la base de données.

2. Séparation des serveurs d'images

Comme nous le savons tous, pour les serveurs web, qu'il s'agisse d'Apache, IIS ou autres conteneurs, les images consomment le plus de ressources, nous Il est nécessaire de séparer les images des pages. C'est une stratégie adoptée essentiellement par les grands sites Web. Ils disposent tous de serveurs d'images indépendants, voire de nombreux serveurs d'images. Une telle architecture peut réduire la pression sur le système serveur qui fournit les demandes d'accès aux pages et garantir que le système ne tombera pas en panne en raison de problèmes d'image. Différentes optimisations de configuration peuvent être effectuées sur le serveur d'applications et le serveur d'images. Par exemple, Apache peut le faire. faites de votre mieux lors de la configuration de ContentType. Prenez en charge le moins possible et utilisez le moins de LoadModules possible pour garantir une consommation système et une efficacité d'exécution plus élevées.

3. Hachage de cluster de base de données et de table de base de données

Les grands sites Web ont des applications complexes, et ces applications doivent utiliser des bases de données lorsqu'elles sont confrontées à un grand nombre d'accès, le goulot d'étranglement. de la base de données apparaîtra bientôt. À ce stade, une base de données ne sera bientôt plus en mesure de répondre à l'application, nous devons donc utiliser le clustering de base de données ou le hachage de table de base de données.

En termes de clusters de bases de données, de nombreuses bases de données ont leurs propres solutions. Oracle, Sybase, etc. ont de bonnes solutions. Le maître/esclave couramment utilisé fourni par MySQL est également une solution similaire. utiliser ?DB, référez-vous simplement à la solution correspondante pour l'implémenter.

Le cluster de bases de données mentionné ci-dessus sera limité par le type de base de données utilisé en termes d'architecture, de coût et d'évolutivité, nous devons donc envisager d'améliorer l'architecture du système du point de vue de l'application. Le hachage de table de bibliothèque est couramment utilisé et. est la solution la plus efficace. Nous installons des modules métiers et applicatifs ou fonctionnels dans l'application pour séparer la base de données. Différents modules correspondent à différentes bases de données ou tables, puis utilisons certaines stratégies pour effectuer des hachages de base de données plus petits sur une certaine page ou fonction, comme la table utilisateur. table en fonction de l'ID utilisateur, ce qui peut améliorer les performances du système à faible coût et avoir une bonne évolutivité. Le forum de Sohu adopte une telle structure, qui sépare les utilisateurs, les paramètres, les publications et autres informations du forum dans une base de données, puis hache les publications et les utilisateurs dans des bases de données et des tableaux en fonction des sections et des identifiants. Enfin, il peut être simplement configuré dans la configuration. Cela permet au système d'ajouter une base de données à faible coût à tout moment pour compléter les performances du système.

4. Mise en cache

Chaque technicien a rencontré le mot cache, et le cache est utilisé à de nombreux endroits. La mise en cache dans l’architecture et le développement de sites Web est également très importante. Ici, nous parlons d’abord des deux caches les plus basiques. La mise en cache avancée et distribuée est décrite plus loin.
Concernant la mise en cache architecturale, toute personne familiarisée avec Apache sait qu'Apache fournit son propre module de mise en cache, ou que vous pouvez utiliser un module Squid supplémentaire pour la mise en cache. Les deux méthodes peuvent améliorer efficacement les capacités de réponse d'accès d'Apache.
Pour la mise en cache dans le développement de programmes de sites Web, Memory Cache fourni sur Linux est une interface de mise en cache couramment utilisée et peut être utilisée dans le développement Web. Par exemple, lors du développement en Java, vous pouvez appeler MemoryCache pour mettre en cache et communiquer avec certaines données. à grande échelle La communauté utilise cette architecture. De plus, lors de l'utilisation du développement d'un langage Web, chaque langage a essentiellement son propre module de cache et sa propre méthode. PHP a le module Cache de Pear, et Java en a encore plus. Je ne connais pas très bien .net, mais je pense qu'il doit être là.

5. Mirroring

La mise en miroir est une méthode souvent utilisée par les grands sites Web pour améliorer les performances et la sécurité des données. La technologie de mise en miroir peut résoudre le problème des différents fournisseurs d'accès au réseau et géographiques. zones. La différence dans les vitesses d'accès des utilisateurs, comme la différence entre ChinaNet et EduNet, a incité de nombreux sites Web à créer des sites miroirs au sein du réseau éducatif, et les données sont mises à jour régulièrement ou en temps réel. En ce qui concerne la technologie détaillée de la mise en miroir, je n'entrerai pas dans les détails ici. Il existe de nombreuses architectures et produits de solutions professionnelles disponibles dans le commerce. Il existe également des moyens peu coûteux de l'implémenter via des logiciels, tels que rsync et d'autres outils sous Linux.

6. Équilibrage de charge

L'équilibrage de charge sera la solution ultime pour les grands sites Web afin de résoudre les accès à charge élevée et un grand nombre de requêtes simultanées.

La technologie d'équilibrage de charge est développée depuis de nombreuses années et il existe de nombreux fournisseurs de services et produits professionnels parmi lesquels choisir. J'ai personnellement rencontré certaines solutions, et deux d'entre elles peuvent être utilisées comme référence.

1) Commutation matérielle de couche quatre

La commutation de couche 4 utilise les informations d'en-tête des paquets de couche 3 et 4 pour identifier le flux commercial en fonction de l'intervalle d'application et combiner le flux commercial de l'ensemble intervalle Attribué au serveur d’applications approprié pour le traitement. La fonction de commutation de couche 4 est comme une adresse IP virtuelle pointant vers le serveur physique. Les services qu'il transmet obéissent à divers protocoles, notamment HTTP, FTP, NFS, Telnet ou d'autres protocoles. Ces services nécessitent des algorithmes complexes d'équilibrage de charge basés sur des serveurs physiques. Dans le monde IP, le type de service est déterminé par l'adresse du port TCP ou UDP du terminal. Dans la commutation de couche 4, la plage d'applications est déterminée par les adresses IP source et terminale, les ports TCP et UDP.

Dans le domaine des produits matériels de commutation à quatre couches, il existe des produits bien connus parmi lesquels choisir, tels que Alteon, F5, etc. Ces produits sont chers, mais ils en valent la peine et peuvent fournir très excellentes performances et capacité de gestion très flexible. Yahoo Chine a utilisé trois ou quatre Alteon pour gérer près de 2 000 serveurs.

2) Commutation logicielle à quatre couches

Une fois que tout le monde connaît le principe du commutateur matériel à quatre couches, une commutation logicielle à quatre couches basée sur le modèle OSI a émergé. Le principe est le même, mais les performances sont légèrement moins bonnes. Cependant, il est toujours facile de répondre à une certaine pression. Certains disent que la méthode de mise en œuvre du logiciel est en réalité plus flexible et que la puissance de traitement dépend entièrement de la familiarité de votre configuration.

Nous pouvons utiliser le LVS couramment utilisé sur Linux pour résoudre la commutation logicielle à quatre couches. LVS est un serveur virtuel Linux. Il fournit une solution de réponse aux catastrophes en temps réel basée sur la ligne de battement de cœur, ce qui améliore la robustesse de. le système et peut Il fournit des fonctions flexibles de configuration et de gestion VIP virtuelles qui peuvent répondre aux exigences de plusieurs applications en même temps, ce qui est essentiel pour les systèmes distribués.

Une stratégie typique d'équilibrage de charge consiste à créer un cluster Squid basé sur une commutation logicielle ou matérielle à quatre couches. Cette idée est adoptée par de nombreux grands sites Web, y compris les moteurs de recherche. Cette architecture est peu coûteuse, haute performance et. Forte évolutivité, il est très simple d’ajouter ou de supprimer des nœuds à l’architecture à tout moment. Je vais détailler cette structure et en discuter avec vous.

Méthode de conception Java pour la gestion des bases de données dans des sites Web à haute concurrence et à forte charge (tutoriel Java, traitement Java de grandes quantités de données, données Java à charge élevée)

1 : La base de données qui est au centre des sites Web à forte concurrence et à forte charge

Oui, le premier est la base de données, qui est le premier SPOF rencontré par la plupart des applications. Surtout pour les applications Web2.0, la réponse de la base de données doit être résolue en premier.
D'une manière générale, MySQL est le plus couramment utilisé. Il peut s'agir d'un hôte MySQL au début. Lorsque les données atteignent plus d'un million, les performances de MySQL diminuent fortement. Une mesure d'optimisation courante est le mode M-S (maître-esclave) pour la réplication synchrone, dans lequel les requêtes et les opérations sont effectuées sur différents serveurs. Ce que je recommande, c'est la méthode M-M-Slaves, 2 maîtres Mysql, plusieurs Esclaves. Il est à noter que bien qu'il y ait 2 Maîtres, un seul est Actif en même temps. On peut switcher à un certain moment. La raison de l'utilisation de deux M est de garantir que M ne redeviendra pas le SPOF du système.
Les esclaves peuvent être davantage équilibrés en charge et peuvent être combinés avec LVS pour équilibrer de manière appropriée certaines opérations sur différents esclaves.
L'architecture ci-dessus peut supporter une certaine charge, mais à mesure que le nombre d'utilisateurs augmente encore, les données de votre table utilisateur dépassent 10 millions, puis le M devient SPOF. Vous ne pouvez pas étendre les esclaves de manière arbitraire, sinon le coût de la synchronisation de réplication montera en flèche. Que dois-je faire ? Ma méthode est le partitionnement de table, le partitionnement à partir d'un niveau métier. Le plus simple, prenez les données utilisateur comme exemple. Selon une certaine méthode de segmentation, telle que l'ID, il est segmenté en différents clusters de bases de données.

La base de données globale est utilisée pour les requêtes de métadonnées. L'inconvénient est que chaque fois que vous interrogez, il sera ajouté une fois. Par exemple, si vous souhaitez interroger un utilisateur nightsailer, vous devez d'abord vous rendre dans le groupe de base de données global pour trouver l'identifiant de cluster correspondant à nightsailer, puis accéder au groupe de base de données global. cluster spécifié pour trouver les données réelles du nightsailer.
Chaque cluster peut utiliser le mode m-m ou le mode m-m-esclaves. Il s'agit d'une structure évolutive. À mesure que la charge augmente, vous pouvez simplement ajouter de nouveaux clusters MySQL.

Les choses à noter sont :
1. Désactivez tous les champs d'auto_increment
2 Les identifiants doivent être alloués de manière centralisée à l'aide d'un algorithme commun
3. hôte L'état opérationnel des charges et des services. Si vous avez plus de 30 bases de données MySQL en cours d'exécution, vous comprendrez ce que je veux dire.
4. N'utilisez pas de liens persistants (n'utilisez pas pconnect). Utilisez plutôt un pool de connexion à une base de données tiers tel que sqlrelay, ou faites-le simplement vous-même, car le pool de connexion mysql dans php4 a souvent des problèmes.

2 : Architecture système statique HTML pour les sites Web à haute concurrence et à forte charge

En fait, tout le monde sait que la méthode la plus efficace et la moins coûteuse est le http purement statique :/ /www.ablanxue.com/shtml/201207/776.shtml page html, nous faisons donc de notre mieux pour utiliser des pages statiques pour les pages de notre site Web. Cette méthode la plus simple est en fait la méthode la plus efficace. Cependant, pour les sites Web avec une grande quantité de contenu et des mises à jour fréquentes, nous ne pouvons pas tous les mettre en œuvre manuellement un par un, c'est pourquoi notre système commun de publication d'informations CMS est apparu, comme les chaînes d'information des différents sites portails que nous visitons souvent, et même leurs autres canaux, tout au long de Il est géré et mis en œuvre par le système de diffusion d'informations. Le système de diffusion d'informations peut réaliser la saisie d'informations la plus simple et générer automatiquement des pages statiques. Il peut également avoir des fonctions telles que la gestion des canaux, la gestion des autorisations et l'exploration automatique. grand site Web, il dispose d'un ensemble efficace de , un CMS gérable est essentiel.
　
En plus des portails et des sites Web de publication d'informations, pour les sites Web de type communautaire ayant des exigences d'interactivité élevées, être aussi statique que possible est également un moyen nécessaire pour améliorer les performances des publications et des articles de la communauté pouvant être traités en réel. La statique, puis la re-staticisation en cas de mise à jour, sont également une stratégie largement utilisée. Le méli-mélo de Mop utilise cette stratégie, tout comme la communauté NetEase, etc.
　
Dans le même temps, la staticisation HTML est également un moyen utilisé par certaines stratégies de mise en cache. Pour les applications du système qui utilisent fréquemment des requêtes de base de données mais ont de très petites mises à jour de contenu, vous pouvez envisager d'utiliser la staticisation HTML, telle que publique. forums dans les forums. Informations de configuration, ces informations peuvent être gérées par les forums grand public actuels et stockées dans la base de données. En fait, un grand nombre de ces informations sont appelées par le programme frontal, mais la fréquence de mise à jour est très faible. peut envisager de rendre cette partie du contenu statique lors de la mise à jour de l'arrière-plan. Cela évite une forte concurrence d'un grand nombre de demandes d'accès à la base de données.
　

Solution statique HTML du site Web
Lorsqu'une demande de ressource Servlet atteint le serveur WEB, nous remplirons la page JSP spécifiée pour répondre à la demande :

Demande HTTP-- -Serveur Web---Servlet--Traitement de la logique métier--Accès aux données--Remplir JSP--Demande de réponse

Après la statique HTML :

Demande HTTP---Serveur Web--- Servlet --HTML--Demande de réponse

La demande d'accès statique est la suivante

Servlet :

public void doGet(HttpServletRequest request, HttpServletResponse response)  
        throws ServletException, IOException {  
    if(request.getParameter("chapterId") != null){  
        String chapterFileName = "bookChapterRead_"+request.getParameter("chapterId")+".html";  
        String chapterFilePath = getServletContext().getRealPath("/") + chapterFileName;  
        File chapterFile = new File(chapterFilePath);  
        if(chapterFile.exists()){response.sendRedirect(chapterFileName);return;}//如果有这个文件就告诉浏览器转向   
        INovelChapterBiz novelChapterBiz = new NovelChapterBizImpl();  
        NovelChapter novelChapter = novelChapterBiz.searchNovelChapterById(Integer.parseInt(request.getParameter("chapterId")));//章节信息   
        int lastPageId = novelChapterBiz.searchLastCHapterId(novelChapter.getNovelId().getId(), novelChapter.getId());  
        int nextPageId = novelChapterBiz.searchNextChapterId(novelChapter.getNovelId().getId(), novelChapter.getId());  
        request.setAttribute("novelChapter", novelChapter);  
        request.setAttribute("lastPageId", lastPageId);  
        request.setAttribute("nextPageId", nextPageId);  
        new CreateStaticHTMLPage().createStaticHTMLPage(request, response, getServletContext(),   
                chapterFileName, chapterFilePath, "/bookRead.jsp");  
    }  
}

Classe pour générer du HTML page statique :

package com.jb.y2t034.thefifth.web.servlet;  
import java.io.ByteArrayOutputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.OutputStreamWriter;  
import java.io.PrintWriter;  
import javax.servlet.RequestDispatcher;  
import javax.servlet.ServletContext;  
import javax.servlet.ServletException;  
import javax.servlet.ServletOutputStream;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import javax.servlet.http.HttpServletResponseWrapper;  
/** * 创建HTML静态页面 
* 功能：创建HTML静态页面 
* 时间：2009年1011日 
* 地点：home 
* @author mavk 
* 
*/  public class CreateStaticHTMLPage {  
    /** 
     * 生成静态HTML页面的方法 
     * @param request 请求对象 
     * @param response 响应对象 
     * @param servletContext Servlet上下文 
     * @param fileName 文件名称 
     * @param fileFullPath 文件完整路径 
     * @param jspPath 需要生成静态文件的JSP路径(相对即可) 
     * @throws IOException 
     * @throws ServletException 
     */  
    public void createStaticHTMLPage(HttpServletRequest request, HttpServletResponse response,ServletContext servletContext,String fileName,String fileFullPath,String jspPath) throws ServletException, IOException{  
        response.setContentType("text/html;charset=gb2312");//设置HTML结果流编码(即HTML文件编码)   
        RequestDispatcher rd = servletContext.getRequestDispatcher(jspPath);//得到JSP资源   
        final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();//用于从ServletOutputStream中接收资源   
        final ServletOutputStream servletOuputStream = new ServletOutputStream(){//用于从HttpServletResponse中接收资源   
            public void write(byte[] b, int off,int len){  
                byteArrayOutputStream.write(b, off, len);  
            }  
            public void write(int b){  
                byteArrayOutputStream.write(b);  
            }  
        };  
        final PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(byteArrayOutputStream));//把转换字节流转换成字符流   
        HttpServletResponse httpServletResponse = new HttpServletResponseWrapper(response){//用于从response获取结果流资源(重写了两个方法)   
            public ServletOutputStream getOutputStream(){  
                return servletOuputStream;  
            }  
            public PrintWriter getWriter(){  
                return printWriter;  
            }  
        };  
        rd.include(request, httpServletResponse);//发送结果流   
        printWriter.flush();//刷新缓冲区，把缓冲区的数据输出   
        FileOutputStream fileOutputStream = new FileOutputStream(fileFullPath);  
        byteArrayOutputStream.writeTo(fileOutputStream);//把byteArrayOuputStream中的资源全部写入到fileOuputStream中   
        fileOutputStream.close();//关闭输出流，并释放相关资源   
        response.sendRedirect(fileName);//发送指定文件流到客户端       }  
}

3 : La mise en cache, l'équilibrage de charge et le stockage sont les préoccupations des sites Web à forte concurrence et à forte charge

Cache C'est un autre gros problème. J'utilise habituellement memcached comme cluster de cache. De manière générale, il suffit de déployer environ 10 unités (pool de mémoire 10g). Une chose à noter est que vous ne devez pas utiliser
swap. Il est préférable de désactiver le swap Linux.

负载均衡/加速

可能上面说缓存的时候，有人第一想的是页面静态化，所谓的静态html，我认为这是常识，不属于要点了。页面的静态化随之带来的是静态服务的
负载均衡和加速。我认为Lighttped+Squid是最好的方式了。
LVS b3c39e73f82b358bad409308ba9884dclighttped====>squid(s) ====lighttpd

上面是我经常用的。注意，我没有用apache，除非特定的需求，否则我不部署apache，因为我一般用php-fastcgi配合lighttpd,
性能比apache+mod_php要强很多。

squid的使用可以解决文件的同步等等问题，但是需要注意，你要很好的监控缓存的命中率，尽可能的提高的90%以上。
squid和lighttped也有很多的话题要讨论，这里不赘述。

存储
存储也是一个大问题，一种是小文件的存储，比如图片这类。另一种是大文件的存储，比如搜索引擎的索引，一般单文件都超过2g以上。
小文件的存储最简单的方法是结合lighttpd来进行分布。或者干脆使用Redhat的GFS，优点是应用透明，缺点是费用较高。我是指
你购买盘阵的问题。我的项目中，存储量是2-10Tb，我采用了分布式存储。这里要解决文件的复制和冗余。
这样每个文件有不同的冗余，这方面可以参考google的gfs的论文。
大文件的存储，可以参考nutch的方案，现在已经独立为hadoop子项目。(你可以google it)

其他：
此外，passport等也是考虑的，不过都属于比较简单的了。
四：高并发高负载网站的系统架构之图片服务器分离 
大家知道，对于Web 服务器来说，不管是Apache、IIS还是其他容器，图片是最消耗资源的，于是我们有必要将图片与页面进行分离，这是基本上大型网站都会采用的策略，他 们都有独立的图片服务器，甚至很多台图片服务器。这样的架构可以降低提供页面访问请求的服务器系统压力，并且可以保证系统不会因为图片问题而崩溃，在应用 服务器和图片服务器上，可以进行不同的配置优化，比如apache在配置ContentType的时候可以尽量少支持，尽可能少的LoadModule， 保证更高的系统消耗和执行效率。

利用Apache实现图片服务器的分离
缘由： 
起步阶段的应用，都可能部署在一台服务器上（费用上的原因） 
第一个优先分离的，肯定是数据库和应用服务器。 
第二个分离的，会是什么呢？各有各的考虑，我所在的项目组重点考虑的节约带宽，服务器性能再好，带宽再高，并发来了，也容易撑不住。因此，我这篇文章的重点在这里。这里重点是介绍实践，不一定符合所有情况，供看者参考吧， 
环境介绍： 
WEB应用服务器：4CPU双核2G, 内存4G 
  部署：Win2003/Apache Http Server 2.1/Tomcat6 
数据库服务器：4CPU双核2G, 内存4G 
  部署：Win2003/MSSQL2000 
步骤： 
步骤一：增加2台配置为：2CPU双核2G，内存2G普通服务器，做资源服务器 
  部署：Tomcat6，跑了一个图片上传的简单应用，（记得指定web.xml的682fa04e96c314670032152167ed6ade），并指定域名为res1.***.com,res2.***.com，采用ajp协议 
步骤二：修改Apache httpd.conf配置 
  原来应用的文件上传功能网址为： 
   1、/fileupload.html 
   2、/otherupload.html 
  在httpd.conf中增加如下配置

<VirtualHost *:80>   
  ServerAdmin webmaster@***.com   
  ProxyPass /fileupload.html balancer://rescluster/fileupload lbmethod=byrequests stickysession=JSESSIONID nofailover=Off timeout=5 maxattempts=3      
  ProxyPass /otherupload.html balancer://rescluster/otherupload.html lbmethod=byrequests stickysession=JSESSIONID nofailover=Off timeout=5 maxattempts=3      
  #<!--负载均衡-->   
  <Proxy balancer://rescluster/>   
    BalancerMember ajp://res1.***.com:8009 smax=5 max=500 ttl=120 retry=300 loadfactor=100 route=tomcat1  
    BalancerMember ajp://res2.***.com:8009 smax=5 max=500 ttl=120 retry=300 loadfactor=100 route=tomcat2  
  </Proxy>   
   
< /VirtualHost>

步骤三，修改业务逻辑： 
  所有上传文件在数据库中均采用全url的方式保存，例如产品图片路径存成：http://res1.***.com/upload/20090101/product120302005.jpg

现在，你可以高枕无忧了，带宽不够时，增加个几十台图片服务器，只需要稍微修改一下apache的配置文件，即可。

五：高并发高负载网站的系统架构之数据库集群和库表散列

大型网站都有复杂的应用，这些应用必须使用数据库，那么在面对大量访问的时候，数据库的瓶颈很快就能显现出来，这时一台数据库将很快无法满足应用，于是我们需要使用数据库集群或者库表散列。
　　
　　在数据库集群方面，很多数据库都有自己的解决方案，Oracle、Sybase等都有很好的方案，常用的MySQL提供的Master/Slave也是类似的方案，您使用了什么样的DB，就参考相应的解决方案来实施即可。
　　
　 　上面提到的数据库集群由于在架构、成本、扩张性方面都会受到所采用DB类型的限制，于是我们需要从应用程序的角度来考虑改善系统架构，库表散列是常用并 且最有效的解决方案。我们在应用程序中安装业务和应用或者功能模块将数据库进行分离，不同的模块对应不同的数据库或者表，再按照一定的策略对某个页面或者 功能进行更小的数据库散列，比如用户表，按照用户ID进行表散列，这样就能够低成本的提升系统的性能并且有很好的扩展性。sohu的论坛就是采用了这样的 架构，将论坛的用户、设置、帖子等信息进行数据库分离，然后对帖子、用户按照板块和ID进行散列数据库和表，最终可以在配置文件中进行简单的配置便能让系 统随时增加一台低成本的数据库进来补充系统性能。

集群软件的分类：
一般来讲，集群软件根据侧重的方向和试图解决的问题，分为三大类：高性能集群（High performance cluster，HPC）、负载均衡集群（Load balance cluster， LBC），高可用性集群（High availability cluster，HAC）。
高性能集群（High performance cluster，HPC），它是利用一个集群中的多台机器共同完成同一件任务，使得完成任务的速度和可靠性都远远高于单机运行的效果。弥补了单机性能上的不足。该集群在天气预报、环境监控等数据量大，计算复杂的环境中应用比较多；
负载均衡集群（Load balance cluster， LBC），它是利用一个集群中的多台单机，完成许多并行的小的工作。一般情况下，如果一个应用使用的人多了，那么用户请求的响应时间就会增大，机器的性能也会受到影响，如果使用负载均衡集群，那么集群中任意一台机器都能响应用户的请求，这样集群就会在用户发出服务请求之后，选择当时负载最小，能够提供最好的服务的这台机器来接受请求并相应，这样就可用用集群来增加系统的可用性和稳定性。这类集群在网站中使用较多；
高可用性集群（High availability cluster，HAC），它是利用集群中系统 的冗余，当系统中某台机器发生损坏的时候，其他后备的机器可以迅速的接替它来启动服务，等待故障机的维修和返回。最大限度的保证集群中服务的可用性。这类系统一般在银行，电信服务这类对系统可靠性有高的要求的领域有着广泛的应用。
2 数据库集群的现状
数据库集群是将计算机集群技术引入到数据库中来实现的，尽管各厂商宣称自己的架构如何的完美，但是始终不能改变Oracle当先，大家追逐的事实，在集群的解决方案上Oracle RAC还是领先于包括微软在内的其它数据库厂商，它能满足客户高可用性、高性能、数据库负载均衡和方便扩展的需求。

Oracle’s Real Application Cluster (RAC)
Microsoft SQL Cluster Server (MSCS)
IBM’s DB2 UDB High Availability Cluster(UDB)
Sybase ASE High Availability Cluster (ASE)
MySQL High Availability Cluster (MySQL CS)

基于IO的第三方HA(高可用性)集群
当前主要的数据库集群技术有以上六大类，有数据库厂商自己开发的；也有第三方的集群公司开发的；还有数据库厂商与第三方集群公司合作开发的，各类集群实现的功能及架构也不尽相同。
RAC（Real Application Cluster，真正应用集群）是Oracle9i数据库中采用的一项新技术，也是Oracle数据库支持网格计算环境的核心技术。它的出现解决了传统数据库应用中面临的一个重要问题：高性能、高可伸缩性与低价格之间的矛盾。在很长一段时间里，甲骨文都以其实时应用集群技术(Real Application Cluster，RAC)统治着集群数据库市场

六：高并发高负载网站的系统架构之缓存

Tous les techniciens ont rencontré le mot cache, et le cache est utilisé dans de nombreux endroits. La mise en cache dans l’architecture et le développement de sites Web est également très importante. Ici, nous parlons d’abord des deux caches les plus basiques. La mise en cache avancée et distribuée est décrite plus loin.
Concernant la mise en cache architecturale, toute personne familiarisée avec Apache sait qu'Apache fournit son propre module de mise en cache, ou que vous pouvez utiliser un module Squid supplémentaire pour la mise en cache. Les deux méthodes peuvent améliorer efficacement les capacités de réponse d'accès d'Apache.
Cache dans le développement de programmes de sites Web. Memory Cache fourni sur Linux est une interface de cache couramment utilisée, qui peut être utilisée dans le développement Web, par exemple, lors du développement en Java, vous pouvez appeler MemoryCache pour mettre en cache et communiquer avec certaines données. à grande échelle La communauté utilise cette architecture. De plus, lors de l'utilisation du développement de langages Web, chaque langage a essentiellement son propre module de cache et sa propre méthode. PHP a le module Cache de Pear, et Java en a encore plus. Je ne connais pas très bien .net, mais je pense qu'il doit y en avoir un.

Java Open Source Cache Framework

JBossCache/TreeCache JBossCache est un cache de transactions répliqué qui vous permet de mettre en cache les données d'application au niveau de l'entreprise pour mieux améliorer les performances. Les données du cache sont automatiquement répliquées, vous permettant d'effectuer facilement un travail de cluster entre les serveurs Jboss. JBossCache peut exécuter un service MBean via Jboss Application Service ou d'autres conteneurs J2EE. Bien entendu, il peut également s'exécuter indépendamment. JBossCache comprend deux modules : TreeCache et TreeCacheAOP. TreeCache : est un cache de transactions répliqué structuré en arborescence. TreeCacheAOP -- est un cache "orienté objet" qui utilise AOP pour gérer dynamiquement les POJO.

OSCache OSCacheLa bibliothèque de balises est conçue par OpenSymphony, qui est une application de balises personnalisées JSP révolutionnaire, fournit la fonction d'implémentation d'une mise en mémoire tampon rapide dans les pages JSP existantes. OSCache est un framework de mise en cache J2EE hautes performances largement adopté. OSCache peut être utilisé comme solution de mise en cache courante pour toute application Java. OSCache a les caractéristiques suivantes : mettre en cache n'importe quel objet, vous pouvez mettre en cache des parties de pages jsp ou des requêtes HTTP sans restrictions, et n'importe quel objet java peut être mis en cache. Dispose d'une API complète - L'API OSCache vous offre un programme complet pour contrôler toutes les fonctionnalités d'OSCache. Cache persistant : le cache peut être écrit sur le disque à volonté, permettant ainsi aux données coûteuses à créer de rester en cache, même lors du redémarrage de l'application. Prend en charge le clustering - les données du cache du cluster peuvent être configurées individuellement sans modifier le code. Expiration des enregistrements mis en cache : vous disposez d'un contrôle maximal sur l'expiration des objets mis en cache, y compris des stratégies d'actualisation enfichables si cela n'est pas nécessaire pour les performances par défaut.

JCACHE JCACHE est une spécification standard à venir (JSR 107) qui décrit une méthode de mise en cache temporaire d'objets Java en mémoire, y compris la création d'objets et l'accès partagé, la mise en file d'attente, l'invalidation et la cohérence de chaque JVM. , etc. Il peut être utilisé pour mettre en cache les données les plus fréquemment lues dans les JSP, telles que les catalogues de produits et les listes de prix. Avec JCACHE, les temps de réponse pour la plupart des requêtes sont accélérés grâce à la mise en cache des données (des tests internes montrent que les temps de réponse sont environ 15 fois plus rapides).

Ehcache Ehcache vient d'Hibernate, qui est utilisé dans Hibernate comme solution de mise en cache de données.

Java Caching System JCS est un sous-projet du projet Turbine de Jakarta. Il s'agit d'un outil tampon composite. Les objets peuvent être mis en mémoire tampon et sur le disque dur. Possède des paramètres d’expiration du délai d’expiration de l’objet tampon. Vous pouvez également créer une architecture distribuée avec mise en mémoire tampon via JCS pour obtenir des applications hautes performances. Pour certains objets qui doivent être consultés fréquemment et consomment beaucoup de ressources à chaque accès, ils peuvent être temporairement stockés dans le tampon, ce qui peut améliorer les performances du service. Et JCS est un bon outil de mise en mémoire tampon. Les outils de mise en mémoire tampon peuvent améliorer considérablement les performances des applications où il y a beaucoup plus d'opérations de lecture que d'opérations d'écriture.

SwarmCache SwarmCache est un mécanisme de mise en cache distribué simple mais puissant. Il utilise la multidiffusion IP pour communiquer efficacement entre les instances mises en cache. Il est idéal pour améliorer rapidement les performances des applications Web en cluster.

ShiftOne ShiftOne Object CacheCette bibliothèque Java fournit des fonctionnalités de mise en cache d'objets de base. Les stratégies mises en œuvre sont le premier entré, premier sorti (FIFO), récemment utilisée (LRU) et la moins fréquemment utilisée (LFU). Toutes les stratégies maximisent la taille d'un élément et maximisent sa durée de survie.

WhirlyCache Whirlycache est un cache rapide et configurable d'objets qui existent en mémoire. Il peut accélérer un site Web ou une application en mettant en cache des objets qui devraient autrement être créés en interrogeant une base de données ou d'autres processus coûteux.

Jofti Jofti peut indexer et rechercher des objets dans la couche cache (prend en charge EHCache, JBossCache et OSCache) ou dans des structures de stockage prenant en charge l'interface Map. Le cadre offre également de la transparence pour l'ajout, la suppression et la modification d'objets dans l'index ainsi que des fonctionnalités de requête faciles à utiliser pour la recherche.

cache4j cache4j est un cache d'objets Java avec une API simple et une implémentation rapide. Ses fonctionnalités incluent : la mise en cache en mémoire, conçue pour les environnements multithread, deux implémentations : synchronisation et blocage, plusieurs stratégies d'effacement du cache : LFU, LRU, FIFO, l'utilisation de références fortes (strong reference) et de références logicielles (soft reference) stockage objet.

Open Terracotta Un framework de clustering open source au niveau JVM qui fournit : la réplication de session HTTP, la mise en cache distribuée, le clustering POJO et les JVM entre les clusters pour réaliser la coordination d'applications distribuées (en utilisant la méthode d'injection de code, vous n'avez donc rien à modifier).

Le système de mise en cache d'objets utilisé par sccache SHOP.COM. sccache est un cache en cours de processus et un cache partagé de deuxième niveau. Il stocke les objets mis en cache sur le disque. Prend en charge les clés associées, les clés de toute taille et les données de toute taille. Possibilité d'effectuer automatiquement le garbage collection.

Shoal Shoal est un framework de clustering dynamique extensible basé sur Java qui fournit un support d'infrastructure pour la création d'applications Java tolérantes aux pannes, fiables et disponibles. Ce framework peut également être intégré à tout produit Java qui ne souhaite pas être lié à un protocole de communication spécifique, mais nécessite la prise en charge de clusters et de systèmes distribués. Shoal est le moteur de clustering pour les serveurs d'applications GlassFish et JonAS.

Simple-Spring-Memcached Simple-Spring-Memcached, qui encapsule les appels à MemCached, rendant le développement du client MemCached extrêmement simple.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!