Beispiele für Lösungen mit hoher Parallelität und Hochlastoptimierung in Java

Eine kleine Website, beispielsweise eine persönliche Website, kann mit der einfachsten statischen HTML-Seite implementiert werden, mit einigen Bildern, um einen verschönernden Effekt zu erzielen. Eine solche Website hat einen großen Einfluss auf das System Architektur und Leistung sind sehr einfach. Mit der kontinuierlichen Bereicherung von Internet-Unternehmen sind die Technologien, die sich auf Websites beziehen, nach Jahren der Entwicklung sehr vielfältig An Software, Programmiersprachen, Datenbanken, Webserver, Firewalls und andere Bereiche werden sehr hohe Anforderungen gestellt, die nicht mehr mit der ursprünglichen einfachen statischen HTML-Website vergleichbar sind.

Große Websites, wie z. B. Portale. Angesichts einer großen Anzahl von Benutzerzugriffen und einer hohen Anzahl gleichzeitiger Anforderungen konzentrieren sich die Basislösungen auf die folgenden Verknüpfungen: Verwendung von Hochleistungsservern, Hochleistungsdatenbanken, hocheffizienten Programmiersprachen und leistungsstarken Webcontainern. Abgesehen von diesen Aspekten gibt es jedoch keine grundsätzliche Lösung für die Probleme mit hoher Auslastung und hoher Parallelität, mit denen große Websites konfrontiert sind.

Die verschiedenen oben genannten Lösungsideen bedeuten bis zu einem gewissen Grad auch größere Investitionen, und solche Lösungsideen weisen Engpässe auf und weisen keine gute Skalierbarkeit auf. Im Folgenden werde ich mit niedrigen Kosten, hoher Leistung und hoher Qualität beginnen einige meiner Erfahrungen aus einer Expansionsperspektive.

1. HTML-Statik

Tatsächlich weiß jeder, dass die rein statische HTML-Seite am effizientesten ist und am wenigsten verbraucht wird. Deshalb geben wir unser Bestes, um unsere Website zu erstellen Die Seiten werden mithilfe statischer Seiten implementiert. Diese einfachste Methode ist tatsächlich die effektivste Methode. Bei Websites mit einer großen Menge an Inhalten und häufigen Aktualisierungen können wir jedoch nicht alle manuell einzeln implementieren, sodass unser gemeinsames Informationsveröffentlichungssystem CMS erschien, z. B. die Nachrichtenkanäle verschiedener Portalseiten, die wir häufig besuchen, und sogar andere Kanäle, alle durch Es wird vom Informationsfreigabesystem verwaltet und implementiert. Das Informationsfreigabesystem kann die einfachste Informationseingabe realisieren und automatisch statische Seiten generieren. Es kann auch über Funktionen wie Kanalverwaltung, Berechtigungsverwaltung, automatisches Crawlen usw. verfügen Für eine große Website ist ein effizientes und überschaubares CMS unerlässlich.

Neben Portalen und Informationsveröffentlichungs-Websites ist es auch für Community-artige Websites mit hohen Interaktivitätsanforderungen ein notwendiges Mittel, um die Leistung zu verbessern. Beiträge und Artikel in der Community können real verarbeitet werden Die Statikisierung und die anschließende Neustatisierung bei einem Update ist ebenfalls eine weit verbreitete Strategie. Mops Sammelsurium nutzt diese Strategie ebenso wie die NetEase-Community und so weiter.

Gleichzeitig ist HTML-Static auch ein Mittel, das von einigen Caching-Strategien verwendet wird. Für Anwendungen im System, die häufig Datenbankabfragen verwenden, aber nur sehr kleine Inhaltsaktualisierungen haben, können Sie die Verwendung von HTML-Static in Betracht ziehen, um dies zu erreichen. B. in öffentlichen Foren, können diese Informationen von den aktuellen Mainstream-Foren verwaltet und in der Datenbank gespeichert werden. Tatsächlich werden viele dieser Informationen vom Front-End-Programm aufgerufen, die Aktualisierungshäufigkeit ist jedoch sehr hoch klein. Sie können diesen Teil des Inhalts statisch machen, wenn Sie den Hintergrund aktualisieren. Dadurch wird eine große Anzahl von Datenbankzugriffsanfragen vermieden.

2. Trennung von Bildservern

Wie wir alle wissen, verbrauchen Bilder bei Webservern, egal ob es sich um Apache, IIS oder andere Container handelt, die meisten Ressourcen Es ist notwendig, Bilder von Seiten zu trennen. Dies ist eine Strategie, die grundsätzlich von großen Websites übernommen wird. Sie verfügen alle über unabhängige Bildserver oder sogar über viele Bildserver. Eine solche Architektur kann den Druck auf das Serversystem verringern, das Seitenzugriffsanforderungen bereitstellt, und sicherstellen, dass das System nicht aufgrund von Bildproblemen abstürzt. Auf dem Anwendungsserver und dem Bildserver können beispielsweise verschiedene Konfigurationsoptimierungen durchgeführt werden Versuchen Sie Ihr Bestes, wenn Sie ContentType so wenig wie möglich konfigurieren und so wenige LoadModules wie möglich verwenden, um einen höheren Systemverbrauch und eine höhere Ausführungseffizienz sicherzustellen.

3. Datenbankcluster und Datenbanktabellen-Hashing

Große Websites verfügen über komplexe Anwendungen, und diese Anwendungen müssen Datenbanken verwenden, wenn sie mit einer großen Anzahl von Zugriffen konfrontiert werden Da eine Datenbank bald nicht mehr in der Lage ist, die Anwendung zu erfüllen, müssen wir Datenbank-Clustering oder Datenbanktabellen-Hashing verwenden.

In Bezug auf Datenbankcluster haben viele Datenbanken ihre eigenen Lösungen. Die häufig verwendeten Master/Slave-Lösungen von MySQL sind ebenfalls eine ähnliche Lösung DB verwenden, beziehen Sie sich einfach auf die entsprechende Lösung, um es zu implementieren.

Der oben erwähnte Datenbankcluster wird durch die Art der verwendeten Datenbank hinsichtlich Architektur, Kosten und Skalierbarkeit eingeschränkt, daher müssen wir eine Verbesserung der Systemarchitektur aus Sicht der Anwendung in Betracht ziehen ist die effektivste Lösung. Wir installieren Geschäfts- und Anwendungs- oder Funktionsmodule in der Anwendung, um die Datenbank zu trennen. Verschiedene Module entsprechen verschiedenen Datenbanken oder Tabellen und verwenden dann bestimmte Strategien, um kleinere Datenbank-Hashes auf einer bestimmten Seite oder Funktion durchzuführen, z. B. der Benutzertabelle Tabelle nach Benutzer-ID, was die Leistung des Systems bei geringen Kosten verbessern und eine gute Skalierbarkeit aufweisen kann. Das Forum von Sohu verwendet eine solche Struktur, die die Benutzer, Einstellungen, Beiträge und andere Informationen des Forums in einer Datenbank aufteilt und dann die Datenbank und die Tabellen der Beiträge und Benutzer nach Abschnitten und IDs hasht. Schließlich kann es einfach in der Konfiguration konfiguriert werden Dadurch kann das System jederzeit eine kostengünstige Datenbank hinzufügen, um die Systemleistung zu ergänzen.

4. Caching

Jeder Techniker ist auf das Wort Cache gestoßen, und Cache wird an vielen Stellen verwendet. Caching ist auch in der Website-Architektur und Website-Entwicklung sehr wichtig. Hier sprechen wir zunächst über die beiden grundlegendsten Caches. Erweitertes und verteiltes Caching werden später beschrieben.
Was das architektonische Caching betrifft, weiß jeder, der mit Apache vertraut ist, dass Apache ein eigenes Caching-Modul bereitstellt, oder Sie können ein zusätzliches Squid-Modul zum Caching verwenden. Beide Methoden können die Zugriffsantwortfunktionen von Apache effektiv verbessern.
Für das Caching bei der Website-Programmentwicklung ist der unter Linux bereitgestellte Memory Cache eine häufig verwendete Caching-Schnittstelle, die bei der Entwicklung in Java verwendet werden kann. Beispielsweise können Sie MemoryCache aufrufen, um einige Daten zwischenzuspeichern und mit ihnen zu kommunizieren groß angelegt Die Community nutzt diese Architektur. Darüber hinaus verfügt jede Sprache bei der Web-Sprachentwicklung grundsätzlich über das Cache-Modul von Pear, und Java ist mit .net noch nicht sehr vertraut, aber ich glaube, dass es vorhanden sein muss.

5. Spiegelung

Spiegelung ist eine Methode, die häufig von großen Websites verwendet wird, um die Leistung und Datensicherheit zu verbessern und das Problem verschiedener Netzwerkzugangsanbieter und geografischer Regionen zu lösen Der Unterschied in den Benutzerzugriffsgeschwindigkeiten, wie z. B. der Unterschied zwischen ChinaNet und EduNet, hat viele Websites dazu veranlasst, Spiegelseiten innerhalb des Bildungsnetzwerks zu erstellen, und die Daten werden regelmäßig oder in Echtzeit aktualisiert. Was die detaillierte Technologie der Spiegelung angeht, werde ich hier nicht zu sehr ins Detail gehen. Es stehen viele professionelle Standardlösungsarchitekturen und -produkte zur Auswahl. Es gibt auch kostengünstige Möglichkeiten, dies über Software wie rsync und andere Tools unter Linux zu implementieren.

6. Lastausgleich

Der Lastausgleich ist die ultimative Lösung für große Websites, um Zugriffe mit hoher Last und eine große Anzahl gleichzeitiger Anforderungen zu bewältigen.

Lastausgleichstechnologie wird seit vielen Jahren entwickelt und es stehen viele professionelle Dienstleister und Produkte zur Auswahl. Ich persönlich bin auf einige Lösungen gestoßen, von denen zwei als Referenz dienen können.

1) Hardware-Layer-4-Switching

Layer-4-Switching verwendet die Header-Informationen von Layer-3- und Layer-4-Paketen, um den Geschäftsfluss entsprechend dem Anwendungsintervall zu identifizieren und den Geschäftsfluss des Ganzen zu kombinieren Wird dem entsprechenden Anwendungsserver zur Verarbeitung zugewiesen. Die Layer-4-Switching-Funktion ist wie eine virtuelle IP, die auf den physischen Server verweist. Die von ihm übertragenen Dienste gehorchen einer Vielzahl von Protokollen, darunter HTTP, FTP, NFS, Telnet oder anderen Protokollen. Diese Dienste erfordern komplexe Lastausgleichsalgorithmen auf Basis physischer Server. In der IP-Welt wird der Diensttyp durch die TCP- oder UDP-Portadresse des Terminals bestimmt. Beim Layer-4-Switching wird der Anwendungsbereich durch die Quell- und Terminal-IP-Adressen, TCP- und UDP-Ports bestimmt.

Im Bereich der Hardware-Vierschicht-Switching-Produkte stehen einige bekannte Produkte zur Auswahl, wie z. B. Alteon, F5 usw. Diese Produkte sind teuer, aber ihr Geld wert und können sie bieten Sehr hervorragende Leistung und sehr flexible Managementfähigkeit. Yahoo China nutzte drei oder vier Alteons, um fast 2.000 Server zu verwalten.

2) Software-Vierschicht-Switching

Nachdem jeder das Prinzip der Hardware-Vierschicht-Umschaltung kennt, wurde eine solche Lösung implementiert Das Prinzip ist das gleiche, die Leistung ist jedoch etwas schlechter. Es ist jedoch immer noch einfach, einem gewissen Druck standzuhalten. Einige Leute sagen, dass die Software-Implementierungsmethode tatsächlich flexibler ist und die Verarbeitungsleistung vollständig von der Vertrautheit Ihrer Konfiguration abhängt.

Wir können das häufig verwendete LVS unter Linux verwenden, um das vierschichtige Software-Switching zu lösen. LVS ist ein Linux Virtual Server. Es bietet eine Echtzeit-Katastrophenreaktionslösung, die die Robustheit von verbessert Das System und kann Es bietet flexible virtuelle VIP-Konfigurations- und Verwaltungsfunktionen, die mehrere Anwendungsanforderungen gleichzeitig erfüllen können, was für verteilte Systeme unerlässlich ist.

Eine typische Lastausgleichsstrategie besteht darin, einen Squid-Cluster basierend auf Software- oder Hardware-Vierschicht-Switching aufzubauen. Diese Idee wird von vielen großen Websites, einschließlich Suchmaschinen, übernommen. Diese Architektur ist kostengünstig, hochleistungsfähig und Aufgrund der starken Skalierbarkeit ist es jederzeit sehr einfach, Knoten zur Architektur hinzuzufügen oder zu entfernen. Diese Struktur werde ich im Detail klären und mit Ihnen besprechen.

Java-Entwurfsmethode für den Umgang mit Datenbanken auf Websites mit hoher Parallelität und hoher Auslastung (Java-Tutorial, Java-Verarbeitung großer Datenmengen, Java-Hochlastdaten)

1: Die Datenbank, die im Mittelpunkt von Websites mit hoher Parallelität und hoher Auslastung steht

Ja, das erste ist die Datenbank, das erste SPOF, mit dem die meisten Anwendungen konfrontiert sind. Insbesondere bei Web2.0-Anwendungen muss zunächst die Antwort der Datenbank gelöst werden.
Im Allgemeinen wird MySQL am häufigsten verwendet. Wenn die Datenmenge auf mehr als 1 Million ansteigt, sinkt die Leistung von MySQL stark. Eine häufig verwendete Optimierungsmaßnahme ist der M-S-Modus (Master-Slave) für die synchrone Replikation, bei dem Abfragen und Vorgänge auf verschiedenen Servern ausgeführt werden. Was ich empfehle, ist die M-M-Slaves-Methode, 2 Master-MySQL, mehrere Slaves. Es ist zu beachten, dass es zwar 2 Master gibt, aber nur einer gleichzeitig aktiv ist. Wir können zu einem bestimmten Zeitpunkt wechseln. Der Grund für die Verwendung von zwei M besteht darin, sicherzustellen, dass M nicht wieder zum SPOF des Systems wird.
Slaves können weiter belastet werden und können mit LVS kombiniert werden, um ausgewählte Vorgänge entsprechend auf verschiedene Slaves zu verteilen.
Die obige Architektur kann eine gewisse Last bewältigen, aber wenn die Anzahl der Benutzer weiter zunimmt, übersteigt Ihre Benutzertabellendaten 10 Millionen, und dann wird M zu SPOF. Sie können Slaves nicht beliebig erweitern, da sonst die Kosten für die Replikationssynchronisierung in die Höhe schnellen. Was soll ich tun? Meine Methode ist die Tabellenpartitionierung, also die Partitionierung auf Unternehmensebene. Am einfachsten ist es, Benutzerdaten als Beispiel zu nehmen. Gemäß einer bestimmten Segmentierungsmethode, z. B. der ID, wird es in verschiedene Datenbankcluster segmentiert.

Die globale Datenbank wird für die Metadatenabfrage verwendet. Der Nachteil besteht darin, dass es bei jeder Abfrage einmal hinzugefügt wird. Wenn Sie beispielsweise einen Benutzer Nightsailer abfragen möchten, müssen Sie zuerst zur globalen Datenbankgruppe gehen, um die Cluster-ID zu finden, die Nightsailer entspricht, und dann zu gehen angegebenen Cluster, um die tatsächlichen Daten von Nightsailer zu finden.
Jeder Cluster kann den M-M-Modus oder den M-M-Slaves-Modus verwenden. Dies ist eine skalierbare Struktur. Wenn die Last zunimmt, können Sie einfach neue MySQL-Cluster hinzufügen.

Zu beachten sind:
1. Deaktivieren Sie alle Auto_Inkrementierungsfelder
2. Es muss eine bessere Methode zur Überwachung von MySQL geben Host Der Betriebsstatus von Lasten und Diensten. Wenn bei Ihnen mehr als 30 MySQL-Datenbanken laufen, werden Sie verstehen, was ich meine.
4. Verwenden Sie keine dauerhaften Links (verwenden Sie stattdessen keinen Datenbankverbindungspool eines Drittanbieters wie SQLRelay) oder machen Sie es einfach selbst, da der MySQL-Verbindungspool in PHP4 häufig Probleme hat.

2: Statische HTML-Systemarchitektur für Websites mit hoher Parallelität und hoher Auslastung

Tatsächlich weiß jeder, dass die effizienteste und kostengünstigste Methode reines statisches http ist :/ /www.ablanxue.com/shtml/201207/776.shtml HTML-Seite, daher versuchen wir unser Bestes, statische Seiten für die Seiten auf unserer Website zu verwenden. Diese einfachste Methode ist tatsächlich die effektivste Methode. Bei Websites mit einer großen Menge an Inhalten und häufigen Aktualisierungen können wir jedoch nicht alle manuell einzeln implementieren, sodass unser gemeinsames Informationsveröffentlichungssystem CMS erschien, z. B. die Nachrichtenkanäle verschiedener Portalseiten, die wir häufig besuchen, und sogar andere Kanäle, alle durch Es wird vom Informationsfreigabesystem verwaltet und implementiert. Das Informationsfreigabesystem kann die einfachste Informationseingabe realisieren und automatisch statische Seiten generieren. Es kann auch über Funktionen wie Kanalverwaltung, Berechtigungsverwaltung, automatisches Crawlen usw. verfügen Für eine große Website ist ein effizientes und überschaubares CMS unerlässlich.

　
Neben Portalen und Informationsveröffentlichungs-Websites ist es auch für Community-artige Websites mit hohen Anforderungen an die Interaktivität ein notwendiges Mittel, um die Leistung zu verbessern. Beiträge und Artikel in der Community können real verarbeitet werden Die Statikisierung und die anschließende Neustatisierung bei einem Update ist ebenfalls eine weit verbreitete Strategie. Mops Sammelsurium nutzt diese Strategie ebenso wie die NetEase-Community und so weiter.
　
Gleichzeitig ist die HTML-Statisierung auch ein Mittel, das von einigen Caching-Strategien verwendet wird. Für Anwendungen im System, die häufig Datenbankabfragen verwenden, aber nur sehr kleine Inhaltsaktualisierungen aufweisen, können Sie die Verwendung von HTML-Statisierung in Betracht ziehen, z. B. öffentlich Beim Festlegen von Informationen in Foren können diese Informationen von den aktuellen Mainstream-Foren verwaltet und in der Datenbank gespeichert werden. Tatsächlich wird eine große Anzahl dieser Informationen vom Front-End-Programm abgerufen, die Aktualisierungshäufigkeit ist jedoch sehr gering Sie können erwägen, diesen Teil des Inhalts beim Aktualisieren des Hintergrunds statisch zu machen. Dadurch wird eine hohe Parallelität einer großen Anzahl von Datenbankzugriffsanforderungen vermieden.
　

Statische Website-HTML-Lösung

Wenn eine Servlet-Ressourcenanforderung den WEB-Server erreicht, füllen wir die angegebene JSP-Seite aus, um auf die Anfrage zu antworten:

HTTP-Anfrage-- -Webserver---Servlet--Geschäftslogikverarbeitung--Zugriffsdaten--JSP füllen--Antwortanforderung

Nach der HTML-Statisierung:

HTTP-Anfrage---Webserver--- Servlet --HTML--Antwortanforderung

Die statische Zugriffsanforderung lautet wie folgt

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");  
    }  
}

Klasse zum Generieren von HTML statische Seite:

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: Caching, Lastausgleich und Speicherung sind die Anliegen von Websites mit hoher Parallelität und hoher Auslastung

Cache Dies ist ein weiteres großes Problem. Normalerweise verwende ich Memcached als Cache-Cluster. Im Allgemeinen reicht es aus, etwa 10 Einheiten (10 g Speicherpool) bereitzustellen. Beachten Sie, dass Sie

swap nicht verwenden dürfen. Am besten deaktivieren Sie Linux-Swap.

负载均衡/加速

可能上面说缓存的时候，有人第一想的是页面静态化，所谓的静态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)统治着集群数据库市场

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

Jeder Techniker ist auf das Wort Cache gestoßen, und Cache wird an vielen Stellen verwendet. Caching ist auch in der Website-Architektur und Website-Entwicklung sehr wichtig. Hier sprechen wir zunächst über die beiden grundlegendsten Caches. Erweitertes und verteiltes Caching werden später beschrieben.
Was das architektonische Caching betrifft, weiß jeder, der mit Apache vertraut ist, dass Apache ein eigenes Caching-Modul bereitstellt, oder Sie können ein zusätzliches Squid-Modul zum Caching verwenden. Beide Methoden können die Zugriffsantwortfunktionen von Apache effektiv verbessern.
Der unter Linux bereitgestellte Cache ist eine häufig verwendete Cache-Schnittstelle, die beispielsweise bei der Entwicklung mit Java zum Zwischenspeichern und Kommunizieren einiger Daten verwendet werden kann groß angelegt Die Community nutzt diese Architektur. Darüber hinaus verfügt jede Sprache bei der Web-Sprachentwicklung grundsätzlich über das Cache-Modul von Pear, und Java ist mit .net nicht sehr vertraut, aber ich glaube, dass es vorhanden sein muss.

Java Open Source Cache Framework

JBossCache/TreeCache JBossCache ist ein replizierter Transaktionscache, mit dem Sie Anwendungsdaten auf Unternehmensebene zwischenspeichern können, um die Leistung zu verbessern. Cache-Daten werden automatisch repliziert, sodass Sie problemlos Cluster-Arbeiten zwischen Jboss-Servern durchführen können. JBossCache kann einen MBean-Dienst über den Jboss Application Service oder andere J2EE-Container ausführen. Natürlich kann es auch unabhängig ausgeführt werden. JBossCache umfasst zwei Module: TreeCache und TreeCacheAOP. TreeCache – ist ein baumstrukturierter replizierter Transaktionscache. TreeCacheAOP – ist ein „objektorientierter“ Cache, der AOP zur dynamischen Verwaltung von POJOs verwendet.

OSCache OSCacheDie Tag-Bibliothek wurde von OpenSymphony entwickelt, einer bahnbrechenden benutzerdefinierten JSP-Tag-Anwendung. Bietet die Funktion, eine schnelle Speicherpufferung innerhalb vorhandener JSP-Seiten zu implementieren. OSCache ist ein weit verbreitetes, leistungsstarkes J2EE-Caching-Framework, das als allgemeine Caching-Lösung für jede Java-Anwendung verwendet werden kann. OSCache hat die folgenden Eigenschaften: Zwischenspeichern jedes Objekts, Sie können Teile von JSP-Seiten oder HTTP-Anforderungen ohne Einschränkungen zwischenspeichern und jedes Java-Objekt kann zwischengespeichert werden. Verfügt über eine umfassende API – Die OSCache-API bietet Ihnen ein umfassendes Programm zur Steuerung aller OSCache-Funktionen. Persistenter Cache – Der Cache kann nach Belieben auf die Festplatte geschrieben werden, sodass kostspielig zu erstellende Daten auch nach Neustarts der Anwendung zwischengespeichert bleiben. Unterstützt Clustering – Cluster-Cache-Daten können individuell konfiguriert werden, ohne den Code zu ändern. Ablauf von zwischengespeicherten Datensätzen – Sie haben maximale Kontrolle über den Ablauf von zwischengespeicherten Objekten, einschließlich anpassbarer Aktualisierungsstrategien, wenn dies für die Standardleistung nicht erforderlich ist.

JCACHE JCACHE ist eine bevorstehende Standardspezifikation (JSR 107), die eine Methode zum vorübergehenden Zwischenspeichern von Java-Objekten im Speicher beschreibt, einschließlich Objekterstellung und gemeinsamem Zugriff, Spooling, Invalidierung und Konsistenz jeder JVM , usw. Es kann verwendet werden, um die am häufigsten gelesenen Daten innerhalb von JSPs zwischenzuspeichern, beispielsweise Produktkataloge und Preislisten. Mit JCACHE werden die Antwortzeiten für die meisten Abfragen durch zwischengespeicherte Daten beschleunigt (interne Tests zeigen, dass die Antwortzeiten etwa 15-mal schneller sind).

Ehcache Ehcache stammt von Hibernate und wird in Hibernate als Daten-Caching-Lösung verwendet.

Java Caching System JCS ist ein Teilprojekt von Jakartas Projekt Turbine. Es handelt sich um ein zusammengesetztes Puffertool. Objekte können im Speicher und auf der Festplatte zwischengespeichert werden. Verfügt über Einstellungen für den Zeitablauf des Pufferobjekts. Sie können auch eine verteilte Architektur mit Pufferung über JCS aufbauen, um Hochleistungsanwendungen zu erreichen. Auf einige Objekte, auf die häufig zugegriffen werden muss und die bei jedem Zugriff viele Ressourcen verbrauchen, können sie vorübergehend im Puffer gespeichert werden, was die Leistung des Dienstes verbessern kann. Und JCS ist ein gutes Puffertool. Pufferungstools können die Leistung von Anwendungen erheblich verbessern, bei denen weit mehr Lesevorgänge als Schreibvorgänge ausgeführt werden.

SwarmCache SwarmCache ist ein einfacher, aber leistungsstarker verteilter Caching-Mechanismus. Es nutzt IP-Multicast, um effizient zwischen zwischengespeicherten Instanzen zu kommunizieren. Es ist ideal, um die Leistung geclusterter Webanwendungen schnell zu verbessern.

ShiftOne ShiftOne Object CacheDiese Java-Bibliothek bietet grundlegende Objekt-Caching-Funktionen. Die implementierten Strategien sind First-in-First-out (FIFO), kürzlich verwendete (LRU) und am wenigsten häufig verwendete (LFU). Alle Strategien maximieren die Größe eines Elements und maximieren seine Überlebenszeit.

WhirlyCache Whirlycache ist ein schneller, konfigurierbarer Cache von Objekten, der im Speicher vorhanden ist. Es kann eine Website oder Anwendung beschleunigen, indem Objekte zwischengespeichert werden, die sonst durch Abfragen einer Datenbank oder andere kostspielige Prozesse erstellt werden müssten.

Jofti Jofti kann Objekte in der Cache-Ebene (unterstützt EHCache, JBossCache und OSCache) oder in Speicherstrukturen, die die Map-Schnittstelle unterstützen, indizieren und durchsuchen. Das Framework bietet außerdem Transparenz für das Hinzufügen, Löschen und Ändern von Objekten im Index sowie benutzerfreundliche Abfragefunktionen für die Suche.

cache4j cache4j ist ein Java-Objekt-Cache mit einer einfachen API und schneller Implementierung. Zu seinen Funktionen gehören: Caching im Speicher, entwickelt für Multithread-Umgebungen, zwei Implementierungen: Synchronisierung und Blockierung, mehrere Cache-Löschstrategien: LFU, LRU, FIFO, die Verwendung von starkem Referenzspeicher (starke Referenz) und weichem Referenzspeicher (Softreferenz). Objekt.

Open Terracotta Ein Open-Source-Clustering-Framework auf JVM-Ebene, das Folgendes bietet: HTTP-Sitzungsreplikation, verteiltes Caching, POJO-Clustering und JVMs über Cluster hinweg, um eine verteilte Anwendungskoordination zu erreichen (mittels Code-Injection-Methode, Sie müssen also nichts ändern).

Das von sccache SHOP.COM verwendete Objekt-Caching-System. sccache ist ein In-Process-Cache und ein gemeinsam genutzter Cache der zweiten Ebene. Es speichert zwischengespeicherte Objekte auf der Festplatte. Unterstützt zugehörige Schlüssel, Schlüssel beliebiger Größe und Daten beliebiger Größe. Möglichkeit zur automatischen Speicherbereinigung.

Shoal Shoal ist ein erweiterbares dynamisches Clustering-Framework auf Java-Basis, das Infrastrukturunterstützung für die Erstellung fehlertoleranter, zuverlässiger und verfügbarer Java-Anwendungen bietet. Dieses Framework kann auch in jedes Java-Produkt integriert werden, das nicht an ein bestimmtes Kommunikationsprotokoll gebunden sein möchte, sondern Cluster- und verteilte Systemunterstützung benötigt. Shoal ist die Clustering-Engine für GlassFish- und JonAS-Anwendungsserver.

Simple-Spring-Memcached Simple-Spring-Memcached, das Aufrufe an MemCached kapselt und die MemCached-Client-Entwicklung extrem einfach macht.

Das obige ist der detaillierte Inhalt vonBeispiele für Lösungen mit hoher Parallelität und Hochlastoptimierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!