SUVBIHNsYWF0IGFsYXJtOiBDcnlwdG8gZW4gQUkgenVsbGVuIHRlZ2VuIDIwMjYgem9yZ2VuIHZvb3IgZWVuIGVub3JtZSBzdGlqZ2luZyB2YW4gaGV0IGVsZWt0cmljaXRlaXRzdmVyYnJ1aWs=

<p><img src="https://gimg2.gateimg.com/image/article/1707408155RDZZ1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen266063"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De vraag naar elektriciteit in de cryptocurrency- en AI-sectoren zal naar verwachting binnen de komende twee jaar verdubbelen.</p>
<p>Er zijn meer dan 8.000 datacenters over de hele wereld die veel energie nodig hebben.</p>
<p>Cannabisfarms en cryptomining zijn verantwoordelijk voor veel elektriciteitsdiefstal in het Verenigd Koninkrijk.</p>
<h2 id="h2-Inleiding283837"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Veel landen kampen met een tekort aan elektriciteit op het moment dat de wereld hard werkt aan het verminderen van de productie van elektriciteit met behulp van fossiele brandstoffen zoals kolen. Naast de beweging naar decarbonisatie zijn er opkomende patronen van elektriciteitsverbruik in veel landen. Bijvoorbeeld, in landen waar crypto mining veel voorkomt, is er vaak een tekort aan elektriciteit, vooral tijdens de winterseizoenen.</p>
<p>Het doel van deze blog is om de wereldwijde elektriciteitsverbruikspatronen te beoordelen, met de nadruk op de crypto- en AI-sectoren. We zullen ook kijken naar de omvang van elektriciteitsdiefstal in het Verenigd Koninkrijk.</p>
<h2 id="h2-Cryptocurrency20en20Kunstmatige20Intelligentie20AI20verbruiken20220van20de20wereldwijde20elektriciteit187240"><a name="Cryptocurrency en Kunstmatige Intelligentie (AI) verbruiken 2% van de wereldwijde elektriciteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptocurrency en Kunstmatige Intelligentie (AI) verbruiken 2% van de wereldwijde elektriciteit</h2><p><a href="https://iea.blob.core.windows.net/assets/ddd078a8-422b-44a9-a668-52355f24133b/Electricity2024-Analysisandforecastto2026.pdf &quot;The International Energy Agency (IEA" rel="nofollow noopener noreferrer" target="_blank">Het rapport van het Internationaal Energieagentschap (IEA)</a> Het rapport geeft aan dat datacenters, crypto en AI 2% van de wereldwijde elektriciteitsvoorziening verbruiken. Het voorspelt ook dat dit verbruik tegen 2026 zal verdubbelen.</p>
<p>Voor de cryptocurrency sector, <a href="https://www.gate.io/learn/course/crypto-mining" target="_blank">crypto mining</a> is verantwoordelijk voor een groot deel van het wereldwijde elektriciteitsverbruik. Dit komt doordat cryptocurrency mining heeft geleid tot de oprichting van veel datacenters waar crypto elektriciteit verbruikt.</p>
<p>In een rapport van 170 pagina’s staat: ‘Het elektriciteitsverbruik van datacenters, kunstmatige intelligentie (AI) en de cryptocurrency sector kan tegen 2026 verdubbelen.’</p>
<p>Ondanks het huidige hoge energieverbruik van crypto, is de groei van het wereldwijde elektriciteitsverbruik gedaald van 2,4% in 2022 naar 2,2% in 2023. De volgende grafiek geeft de voorspelde trend van het elektriciteitsverbruik in de AI- en crypto miningsectoren aan.</p>
<p>Elektriciteitsgebruik door datacenters, AI en Crypto tot 2026 - <a href="https://iea.blob.core.windows.net/assets/ddd078a8-422b-44a9-a668-52355f24133b/Electricity2024-Analysisandforecastto2026.pdf" rel="nofollow noopener noreferrer" target="_blank">IAE</a></p>
<p>Zoals je ziet in <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>, het elektriciteitsverbruik in de sector zal naar verwachting de komende twee jaar toenemen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/250/gate.io-observation-how-to-use-cloud-mining-to-mine-bitcoin-in-just-one-click" target="_blank">Hoe cloud mining te gebruiken om Bitcoin te mijnen in slechts één klik?</a></p>
<p>Hierover zei de IEA: ‘We schatten dat datacenters, cryptocurrencies en kunstmatige intelligentie (AI) wereldwijd ongeveer 460 terawattuur (TWh) aan elektriciteit verbruikten in 2022, bijna 2% van de totale wereldwijde elektriciteitsvraag.’ Als we uitgaan van deze voorspelling, betekent dit dat de twee sectoren tegen 2026 meer dan 1000 TWh kunnen verbruiken.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-btc-mining/287" target="_blank">Wat is BTC mining?</a></p>
<p>IEA is nog verder gegaan om de hoeveelheid elektriciteit te analyseren die traditionele datacenters en toegewijde AI-datacenters tegen 2026 kunnen verbruiken. De volgende grafiek presenteert de cijfers.</p>
<p>Uitval van datacenter, AI en cryptogebruik - <a href="https://iea.blob.core.windows.net/assets/ddd078a8-422b-44a9-a668-52355f24133b/Electricity2024-Analysisandforecastto2026.pdf" rel="nofollow noopener noreferrer" target="_blank">IEA</a></p>
<p>Daarentegen kunt u zien dat traditionele datacenters aanzienlijk minder elektriciteit verbruiken dan speciale AI-datacenters. We hebben een specifiek voorbeeld van ChatGPT dat naar verwachting tijdens de genoemde periode ongeveer 10 TWh per jaar zal verbruiken.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/60-bitcoin-mining-and-energy-consumption-statistics-for-2023-you-need-to-know/1265" target="_blank">60+ Bitcoin Mining- en Energieverbruikstatistieken</a></p>
<p>We kunnen het energieverbruik van datacenters, AI en crypto het beste begrijpen door het huishoudelijk elektriciteitsverbruik te waarderen. Als voorbeeld kan één terawattuur ongeveer 70.000 huizen in de Verenigde Staten een jaar lang van stroom voorzien.</p>
<p>In 2023 alleen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gebruikte meer dan 120 TWh van de 130 TWh <a href="https://www.gate.io/blog_detail/359/understanding-cryptocurrency-mining" target="_blank">volledige cryptominingindustrie</a> Desondanks is het belangrijk om op te merken dat 55,4% van de energievoorziening van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> afkomstig is van duurzame bronnen, hoewel gedeeltelijk geproduceerd met fossiele brandstoffen.</p>
<p>Eind 2023 waren er iets meer dan 8.000 datacenters over de hele wereld. Meer dan een derde daarvan bevindt zich in de Verenigde Staten, 16% in Europa en ongeveer 10% in China. De meeste van deze datacenters zijn gevestigd in grote financiële centra zoals Frankfurt, Amsterdam, Parijs, Londen en Dublin.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/blog_detail/3730/bitcoin-etf-trading-vs-btc-miners-and-traders" target="_blank">Bitcoin ETF Trading versus BTC Miners en Traders</a></p>
<p>Over het algemeen voorspelt het IEA echter dat de vraag naar elektriciteit elk jaar met ongeveer 3,4% zal toenemen tot 2026. Het gaf de redenen voor een dergelijke ontwikkeling aan: “De winst zal worden gestimuleerd door een verbeterend economisch vooruitzicht, wat zal bijdragen aan een snellere groei van de vraag naar elektriciteit in zowel geavanceerde als opkomende economieën.”</p>
<p>Het voegde eraan toe: ‘Met name in geavanceerde economieën en China zal de vraag naar elektriciteit worden ondersteund door de voortdurende elektrificatie van de residentiële en transportsectoren, evenals een opmerkelijke uitbreiding van de datacentersector.’</p>
<h2 id="h2-Opkomende20Crypto20Veroorzaakt20Controverse20Britse20Elektriciteitsdiefstal20en20Illegale20Operaties20Ontdekt392606"><a name="Opkomende Crypto Veroorzaakt Controverse: Britse Elektriciteitsdiefstal en Illegale Operaties Ontdekt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opkomende Crypto Veroorzaakt Controverse: Britse Elektriciteitsdiefstal en Illegale Operaties Ontdekt</h2><p>Een <a href="https://www.bbc.com/news/uk-england-66847243" rel="nofollow noopener noreferrer" target="_blank">BBC-publicatie</a> heeft erop gewezen dat er een toename is van elektriciteitsdiefstal door individuen en organisaties die illegale activiteiten van stroom voorzien. Zo zijn bijvoorbeeld cannabisboerderijen en niet-geregistreerde cryptomijnen verantwoordelijk voor een deel van deze diefstallen. Analisten hebben ook de hoge incidentie van stroomdiefstallen toegeschreven aan een stijging van de kosten van levensonderhoud in Wales en Engeland.</p>
<p>BBC zei dat diefstal van elektriciteit in het Verenigd Koninkrijk sinds 2012 met 75% is toegenomen. Natuurlijk is een groot deel van de toename in diefstallen te wijten aan crypto mining. Aangezien het delven van cryptomunten zoals bitcoin een lucratieve onderneming is, hebben sommige slechte actoren zwakke plekken geïdentificeerd waardoor ze crypto kunnen delven met gestolen elektriciteit.</p>
<p>Volgens de publicatie waren er tussen 2021 en 2022 meer dan 3.500 glen van elektriciteitsdiefstal. Het legde ook uit wat elektriciteitsdiefstal betekent en inhoudt. Er staat: “Bij elektriciteitsdiefstal worden meters gemanipuleerd of omzeild om te voorkomen dat er voor energie wordt betaald.”</p>
<p>Sommige van de <a href="https://www.bbc.com/news/uk-england-66847243" rel="nofollow noopener noreferrer" target="_blank">gevolgen van elektriciteitsdiefstal</a> inclusief het blootleggen van “levende draden… het omzeilen van zekeringkasten, waardoor het risico op oververhitting of brand van apparaten en dood toeneemt.”</p>
<p>Opmerkelijk is dat de <a href="https://iea.blob.core.windows.net/assets/ddd078a8-422b-44a9-a668-52355f24133b/Electricity2024-Analysisandforecastto2026.pdf" rel="nofollow noopener noreferrer" target="_blank">Blob Zorg rapport</a> heeft bewijs geleverd van hoe crypto op illegale wijze elektriciteit gebruikt. Als voorbeeld ontdekte de politie van West Midlands in mei 2021 een bitcoin-mininglocatie op het industrieterrein van Sandwell, met meer dan 100 computers die illegaal op het elektriciteitsnet waren aangesloten. Daarom maken veel regeringen zich zorgen over problemen die verband houden met cryptocurrency en diefstal van elektriciteit.</p>
<h2 id="h2-Conclusie177290"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Een rapport van het Internationaal Energieagentschap (IEA) toont aan dat de vraag naar elektriciteitsgebruik in datacenters, evenals de AI- en crypto miningsectoren, sinds 2021 is gestegen. Het elektriciteitsverbruik in deze sectoren zal naar verwachting in de komende twee jaar verdubbelen. Aan de andere kant heeft de stijging van de elektriciteitskosten geleid tot een toename van stroomdiefstallen, omdat sommige slechte actoren in de mijnbouwsector op zoek zijn naar goedkope energiebronnen.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/learn/articles/bitcoin-mining-a-path-to-electrifying-the-world/1367" target="_blank">Bitcoin Mining: Het pad effenen voor wereldwijde elektrificatie</a></p>
<h2 id="h2-Veelgestelde20vragen20over20Crypto20en20AI20Elektriciteitsverbruik581558"><a name="Veelgestelde vragen over Crypto en AI Elektriciteitsverbruik" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Crypto en AI Elektriciteitsverbruik</h2><h3 id="h3-Hoeveel20elektriciteit20verbruikt20AI750792"><a name="Hoeveel elektriciteit verbruikt AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel elektriciteit verbruikt AI?</h3><p>Kunstmatige intelligentie en cryptocurrency gebruiken ongeveer 2% van de wereldwijde elektriciteitsvoorziening. In 2022 heeft AI ongeveer 400 TWh gebruikt, waarvan de hoeveelheid naar verwachting binnen de komende twee jaar zal verdubbelen.</p>
<h3 id="h3-Hoeveel20elektriciteit20gaat20er20naar20crypto650688"><a name="Hoeveel elektriciteit gaat er naar crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel elektriciteit gaat er naar crypto?</h3><p>In 2023 gebruikte de cryptocurrency sector iets meer dan 130 TWh. Hiervan verbruikte Bitcoin 120 TWh. De reden waarom Bitcoin zoveel elektriciteit verbruikt, is dat crypto mining veel energie vereist.</p>
<h3 id="h3-Wordt20AI20gebruikt20in20crypto163241"><a name="Wordt AI gebruikt in crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wordt AI gebruikt in crypto?</h3><p>AI vervult vele belangrijke rollen in de cryptocurrency sector. Het helpt bij risicobeheer, automatisering van handel en gegevensaggregatie die het nemen van weloverwogen beslissingen mogelijk maken.</p>
<h3 id="h3-Wat20is20cryptomining67247"><a name="Wat is cryptomining?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is cryptomining?</h3><p>Crypto-mining is het proces waarbij nieuwe munten worden geproduceerd met behulp van rekenkracht. Meestal worden de nieuwe munten geproduceerd wanneer gespecialiseerde computeren complexe wiskundige vergelijkingen oplossen als een middel om transacties op een blockchain te valideren. Crypto-mining werkt echter met een proof-of-work consensusmechanisme.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>