# La concurrence en Nim

Nim offre plusieurs mécanismes pour gérer la concurrence et le parallélisme dans vos applications. Ces fonctionnalités permettent d'exploiter efficacement les processeurs multi-cœurs modernes.

## Threads

Nim supporte les threads natifs de l'OS via le module `threads`. 

```nim
import std/[threadpool]

proc processData(data: int) {.thread.} =
  echo "Processing data: ", data

var threads: array[4, Thread[int]]
for i in 0..3:
  createThread(threads[i], processData, i)

joinThreads(threads)
```

## ThreadPool

Pour une gestion plus simple des tâches parallèles, Nim propose le module `threadpool`.

```nim
import std/[threadpool]

proc calculateValue(x: int): int =
  result = x * x

var futures = newSeq[FlowVar[int]](10)
for i in 0..9:
  futures[i] = spawn calculateValue(i)

for i in 0..9:
  echo ^futures[i]
```

## Async/Await

Pour la programmation asynchrone non bloquante, Nim offre le module `asyncdispatch`.

```nim
import std/[asyncdispatch, httpclient, strformat]

proc fetchUrl(url: string) {.async.} =
  let client = newAsyncHttpClient()
  let response = await client.get(url)
  echo fmt"Fetched {url}, size: {response.body.len} bytes"
  client.close()

proc main() {.async.} =
  var fetches = @[
    fetchUrl("https://nim-lang.org"),
    fetchUrl("https://github.com/nim-lang/Nim")
  ]
  await all(fetches)

waitFor main()
```

Ces fonctionnalités de concurrence font de Nim un excellent choix pour développer des applications hautes performances qui exploitent pleinement les capacités des processeurs modernes.