Résoudre les problèmes de haute concurrence dans les systèmes Java

Cet article présente principalement des solutions à haute concurrence pour les systèmes Java. Le contenu est très riche, je le partage avec tout le monde ici et les amis dans le besoin peuvent s'y référer.

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 impact négatif. sur l'architecture du système, les exigences de performances 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. Surtout pour les grands sites Web, les technologies utilisées sont encore plus complexes. large, du matériel au logiciel, en passant par le langage de programmation, mysql" target="_blank" title="MySQL Knowledge Base"> la base de données, le serveur Web, le pare-feu et d'autres domaines ont des exigences très élevées, ce n'est plus le simple HTML statique original

Les grands sites Web, tels que les portails, sont confrontés à un grand nombre de visites d'utilisateurs et à des demandes simultanées élevées. Les solutions de base se concentrent sur les liens suivants : Utiliser des serveurs performants, des bases de données performantes, une efficacité élevée. langages de programmation et conteneurs Web hautes performances, mais en dehors de ces aspects, ils ne peuvent pas résoudre fondamentalement les problèmes de charge élevée et de concurrence élevée rencontrés par les grands sites Web

Les différentes idées de solutions fournies ci-dessus signifient également plus. investissement dans une certaine mesure, et de telles idées de solutions ont des goulots d'étranglement et n'ont pas une bonne évolutivité. Ci-dessous, j'en discuterai du point de vue du faible coût, des performances élevées et de l'évolutivité élevée. Parlons de certaines de mes expériences

1. HTML statique

En fait, tout le monde sait que la méthode la plus efficace et la moins coûteuse est le HTML pur, nous essayons donc d'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 tout faire manuellement, c'est pourquoi notre système commun de diffusion d'informations est CMS. est apparu. Les chaînes d'information des divers sites portails que nous visitons souvent, et même leurs autres chaînes, sont gérées et mises en œuvre via le système de diffusion d'informations. Le système de diffusion d'informations peut réaliser la saisie d'informations la plus simple possible et générer automatiquement des pages statiques. avoir des fonctions telles que la gestion des canaux, la gestion des droits et l'exploration automatique. Pour un site Web de grande taille, disposer d'un CMS efficace et gérable est essentiel
De plus, pour les sites Web de type portail et publication d'informations, pour les sites Web de type communauté avec des exigences d'interactivité élevées, être aussi statique que possible est également un moyen nécessaire pour améliorer les performances. Les publications et les articles de la communauté doivent être rendus statiques en temps réel, et lorsqu'il y a des mises à jour, la statique est également une stratégie largement utilisée. Le méli-mélo de Mop utilise cette stratégie, tout comme NetEase.

Dans le même temps, la staticisation HTML est également une méthode utilisée 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 HTML. implémentation statique, telle que les informations de configuration publique dans les forums. Ces informations peuvent être gérées en arrière-plan par les forums grand public actuels et stockées dans la base de données. En fait, une grande partie de ces informations est appelée par le programme de premier plan, mais la fréquence de mise à jour est. très petit. Vous pouvez envisager de rendre cette partie du contenu statique lors de la mise à jour en arrière-plan, afin d'éviter 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, d'IIS ou d'autres conteneurs, les images sont le plus important Il consomme des ressources, nous devons donc séparer les images des pages. C'est une stratégie essentiellement adoptée 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, donc face à Lorsqu'un grand nombre d'accès se produit, 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 bases de données ou le hachage de tables de bases 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. Quel type de base de données peut être implémenté en se référant à la solution correspondante.

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.

Mise en cache au niveau de l'architecture, toute personne familiarisée avec Apache saura qu'Apache fournit son propre module de mise en cache, et vous pouvez également utiliser le module Squid supplémentaire pour la mise en cache. Les deux méthodes peuvent améliorer efficacement la réactivité 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 en mettre en cache. Pour le partage de données et de communications, certaines grandes communautés utilisent 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. Mise en miroir

La mise en miroir est une méthode souvent utilisée par les grands sites Web pour améliorer les performances et la technologie de mise en miroir peut résoudre le problème de. différents réseaux Les différences dans les vitesses d'accès des utilisateurs causées par les fournisseurs d'accès et les régions, telles que la différence entre ChinaNet et EduNet, ont 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 problèmes simultanés. demandes.

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 4

La commutation de couche 4 utilise les informations d'en-tête des paquets de couche 3 et de couche 4, selon l'application. L'intervalle identifie le flux métier et alloue le flux métier de l'intégralité du segment d'intervalle au serveur d'applications approprié pour 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 peut fournir d'excellentes performances et des capacités de gestion flexibles. 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 de la commutation matérielle à quatre couches, le logiciel à quatre couches est implémenté en fonction sur le modèle OSI, Exchange a vu le jour. Une telle solution implémente le même principe, 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 du système. et offre de la flexibilité. Les fonctions de configuration et de gestion VIP virtuelles 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. Une telle architecture est peu coûteuse et élevée. performances et une forte évolutivité, il est très facile d'ajouter ou de supprimer des nœuds à l'architecture à tout moment. Je vais détailler cette structure et en discuter avec vous.

1 : Bases de données axées sur les 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.

De 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 équilibrer davantage la 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 et que les données de votre table utilisateur dépassent 10 millions, 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.

Il convient de noter que :

1. Désactivez tous les champs d'auto_increment

2. être utilisé Allocation centralisée de l'algorithme universel

3. Il est nécessaire d'avoir une meilleure méthode pour surveiller la charge de l'hôte mysql et l'état d'exécution du service. 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 est en php4). a souvent des problèmes.

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

En fait, tout le monde sait que le plus efficace et le moins Les pages consommées sont purement statiques, 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 statiques que possible est également un moyen nécessaire pour améliorer les performances. Les publications et les articles de la communauté peuvent être rendus statiques en temps réel et mis à jour. La statique est également une stratégie largement utilisée. Le méli-mélo de Mop utilise cette stratégie, tout comme les communautés NetEase.

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, comme dans les forums. Les informations de configuration publique du forum 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 mise à jour. la fréquence est très faible. Vous pouvez envisager de mettre à jour cette partie du contenu en 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 arrive sur le serveur WEB, nous remplirons la page JSP spécifiée pour répondre à la demande :

Requête HTTP---Serveur Web---Servlet--Traitement de la logique métier--Données d'accès--Remplir JSP--Demande de réponse

Après staticisation HTML :

Requête 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 de génération de pages HTML statiques :

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);//发送指定文件流到客户端
}
}

Trois : les sites Web à forte charge simultanée se concentrent sur la mise en cache, l'équilibrage de charge et le stockage

Le cache est un autre gros problème. J'utilise habituellement Memcached comme cluster de cache. De manière générale, il suffit de le faire. déployer environ 10 unités (pool de mémoire 10g). Une chose à noter est que vous ne devez pas utiliser le

swap. Il est préférable de désactiver le swap Linux.

Équilibrage/Accélération de charge

可能上面说缓存的时候，有人第一想的是页面静态化，所谓的静态html，我认为这是常识，不属于要点了。页面的静态化随之带来的是静态服务的

负载均衡和加速。我认为Lighttped+Squid是最好的方式了。

LVS <------->lighttped====>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的），并指定域名为res1.***.com,res2.***.com，采用

ajp协议

步骤二：修改Apache httpd.conf配置

原来应用的文件上传功能网址为：

1、/fileupload.html

2、/otherupload.html

在httpd.conf中增加如下配置

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
#
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
< /VirtualHost>

步骤三，修改业务逻辑：

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

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

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

大型网站都有复杂的应用，这些应用必须使用数据库，那么在面对大量访问的时候，数据库的瓶颈很快就能显现出来，这时一台数据库将很快无法满足应用，于是我们需要使用数据库集群或者库表散列。

　　在数据库集群方面，很多数据库都有自己的解决方案，Oracle、Sybase等都有很好的方案，常用的MySQL提供的Master/Slave也是类似的方案，您使用了什么样的DB，就参考相应的解决方案来实施即可。

Le cluster de bases de données mentionné ci-dessus sera limité par le type de base de données 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 le plus. solution 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.

Classification des logiciels de cluster :

De manière générale, les logiciels de cluster sont divisés en trois grandes catégories en fonction de l'orientation et du problème auquel ils sont confrontés. essaie de résoudre. : Cluster haute performance (HPC), cluster d'équilibrage de charge (LBC), cluster haute disponibilité (HAC).

Cluster haute performance (HPC), qui utilise plusieurs machines dans un cluster pour effectuer la même tâche, ce qui rend la vitesse d'exécution et la fiabilité de la tâche bien supérieures à celles d'une seule machine. Effet opérationnel. Compensez les lacunes des performances autonomes. Ce cluster est largement utilisé dans les environnements contenant de grandes quantités de données et des calculs complexes tels que les prévisions météorologiques et la surveillance environnementale

Cluster d'équilibrage de charge (LBC), qui utilise plusieurs clusters dans un cluster. Une seule machine peut effectuer de nombreuses petites tâches parallèles. De manière générale, si davantage de personnes utilisent une application, le temps de réponse aux demandes des utilisateurs augmentera et les performances de la machine seront également affectées. Si un cluster d'équilibrage de charge est utilisé, n'importe quelle machine du cluster peut répondre aux demandes de l'utilisateur. demandes, de sorte qu'après que l'utilisateur a émis une demande de service, le cluster sélectionnera la machine avec la plus petite charge et le meilleur service pour accepter la demande et répondre. De cette manière, le cluster peut être utilisé pour augmenter la disponibilité et la stabilité. du système. Ce type de cluster est couramment utilisé dans les sites Web ;

Cluster haute disponibilité (HAC), qui utilise la redondance du système dans le cluster, lorsqu'une machine du système est endommagée, d'autres machines de sauvegarde peuvent prendre rapidement le relais pour démarrer le service, en attendant la réparation et le retour de la machine défaillante. Maximisez la disponibilité des services dans le cluster. Ce type de système est généralement largement utilisé dans des domaines tels que les banques et les services de télécommunications qui ont des exigences élevées en matière de fiabilité du système.

2 État actuel des clusters de bases de données

Le clustering de bases de données est obtenu en introduisant la technologie de clustering informatique dans la base de données, bien que chaque fabricant affirme que son Non Quelle que soit la perfection de l'architecture, cela ne changera jamais le fait qu'Oracle prend les devants et que tout le monde le poursuit. Oracle RAC est toujours en avance sur les autres fournisseurs de bases de données, y compris Microsoft, en termes de solutions de cluster. Il peut répondre aux exigences de haute disponibilité des clients. les performances, l'équilibrage de la charge de la base de données et la nécessité d'une expansion facile.

Cluster d'applications réelles (RAC) d'Oracle

Microsoft SQL Cluster Server (MSCS)

Cluster haute disponibilité DB2 UDB d'IBM (UDB)

Cluster haute disponibilité Sybase ASE (ASE)

Cluster haute disponibilité MySQL (MySQL CS)

Tiers basé sur IO Cluster HA (haute disponibilité) tripartite

Les principales technologies de cluster de bases de données actuelles incluent les six catégories ci-dessus, certaines sont développées par les fabricants de bases de données eux-mêmes, d'autres sont développées par des sociétés de cluster tierces ; ; et il existe des bases de données développées par les fabricants en coopération avec des sociétés de cluster tierces, les fonctions et les architectures mises en œuvre par les différents clusters sont également différentes.

RAC (Real Application Cluster, véritable cluster d'applications) est une nouvelle technologie utilisée dans la base de données Oracle9i et constitue également la technologie de base de la base de données Oracle pour prendre en charge l'environnement informatique en grille. Son apparition résout un problème important rencontré dans les applications de bases de données traditionnelles : la contradiction entre hautes performances, haute évolutivité et bas prix. Depuis longtemps, Oracle domine le marché des bases de données en cluster avec sa technologie Real Application Cluster (RAC)

Six : Architecture système pour la mise en cache de sites Web à haute concurrence et à charge élevée

Tous les techniciens ont rencontré le terme cache, et le cache est utilisé dans de nombreux endroits. L'architecture du site Web et la mise en cache dans le développement de sites Web sont également très importantes. 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, et vous pouvez également utiliser le module Squid supplémentaire pour la mise en cache. Les deux méthodes peuvent améliorer efficacement la réactivité 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 des applications d'entreprise pour mettre à jour Nice amélioré performance. 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 POJO

OSCache La bibliothèque de balises OSCache est conçue par OpenSymphony. Il s'agit d'une application de balises personnalisées JSP révolutionnaire qui fournit la fonction d'implémentation. de 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, l'accès partagé et la mise en file d'attente, l'échec, 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 et 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 Cache est une bibliothèque Java qui 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 de 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 est un framework de cluster 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 à travers le cluster pour réaliser la coordination d'applications distribuées (en utilisant l'injection de code, donc vous pas besoin de modifier quoi que ce soit).

sccache Le système de mise en cache d'objets utilisé par 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 cluster dynamique évolutif 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 encapsule les appels à MemCached, ce qui rend le développement du client MemCached extrêmement simple.

Résumé

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!