2015-12-25 9 views
5

Ho un esercizio interessante da risolvere dal mio professore. Ma ho bisogno di un po 'di aiuto in modo che non diventi noioso durante le vacanze.Come posso iniziare a creare un bilanciamento del carico con multithreading?

L'esercizio è

  • creare un bilanciamento del carico multithread, che legge 1 punto di misura da 5 sensori ogni secondo. (quindi 5 valori ogni secondo).
  • Quindi eseguire alcuni calcoli "complessi" con tali valori.
  • Stampa dei risultati dei calcoli sullo schermo. (come valore massimo o valore medio del sensore 1-5 e così via, ovviamente multithread)
  • Come ulteriore compito devo anche assicurarmi che se nel futuro ad esempio 500 sensori sarebbero letti ogni secondo il computer non lo fa t esci dal lavoro (bilanciamento del carico).

Ho un file di testo CSV con ~ 400 punti di misurazione da 5 sensori immaginari.

Quello che penso di avere a che fare:

  1. Leggere i punti di misura in un array
  2. Garantire filo accesso sicuro a tale matrice
  3. Spawn un nuovo thread per ogni valore che calcola alcune cose di matematica
  4. impostare un valore massimo per un massimo di discussioni di lavoro simultanei

sono nuovo di multithreading applicatio ns in C# ma penso che usare threadpool sia la strada giusta. Attualmente sto lavorando su una coda e forse l'avvio all'interno di un'attività in modo che non bloccherà l'applicazione.

Cosa raccomanderesti?

+0

Avete intenzione di calcolare i valori medi, massimi in modo indipendente per ogni sensore? – alexm

+0

sì, questo è il "design". dovrebbe scalare in qualche modo con l'aumento dei sensori ma non dovrebbe uccidere il processore .... –

+0

o più importante: non dovrebbe uccidere l'applicazione e la sua funzione –

risposta

3

ci sono un paio di ambiente dipendenze qui:

  • Quale versione di .NET stai usando?
  • Quale interfaccia utente stai utilizzando: desktop (WPF/WinForms) o ASP.NET?

Supponiamo che sia .NET 4.0 o versione successiva e un'app desktop.

lettura sensori

In un'applicazione WPF o WinForms, userei un singolo BackgroundWorker per leggere i dati dai sensori. 500 letture al secondo sono banali - anche 500,00 di solito sono banali. E il tipo di BackgroundWorker è progettato specificamente per interagire con le app desktop, ad esempio distribuendo i risultati all'interfaccia utente senza preoccuparsi delle interazioni tra thread.

elaborazione dei calcoli

allora avete bisogno di elaborare i calcoli "complessi". Questo dipende da quanto durano questi calcoli. Se assumiamo che abbiano vita breve (diciamo meno di 1 secondo ciascuno), allora penso che l'uso dello TaskScheduler e dello standard ThreadPool andrà bene.Pertanto, per ogni calcolo viene creato un valore Task, quindi il TaskScheduler si occupa dell'allocazione delle attività ai thread.

Il compito del TaskScheduler è di bilanciare il carico del carico accodando attività leggere a thread più pesanti e gestendo il ThreadPool per bilanciare al meglio il carico di lavoro rispetto al numero di core sulla macchina. Puoi anche override the default TaskScheduler programmare le attività nel modo desiderato.

Il ThreadPool è una coda FIFO di elementi di lavoro che devono essere elaborati. In .NET 4.0, il ThreadPool ha migliorato le prestazioni rendendo il lavoro in coda una raccolta ConcurrentQueue thread-safe.

misura il throughput delle applicazioni e l'efficienza

È possibile utilizzare PerformanceCounter di misurare sia CPU and memory usage. Questo ti darà una buona idea se i core e la memoria vengono utilizzati in modo efficiente. Il throughput delle attività viene semplicemente misurato osservando la velocità con cui vengono elaborate le attività e fornendo i risultati.

Si noti che non ho incluso alcun codice qui, come presumo che si desidera trattare con i dettagli di implementazione per il vostro professore :-)

+0

ciao, grazie per il vostro aiuto. è una prova di concetto posso scegliere quello che voglio. quindi C# .net 4 winforms è la cosa che sto lavorando ora con .... –

+0

penso di non averlo spiegato bene ........ la quantità di letture al secondo non è importante, l'importante è che ogni il sensore verrà letto almeno una volta al secondo. quindi una volta al secondo va bene .... forse meglio prima di uccidere il sistema con le attività –

+0

Leggere tutti i sensori e aggiornare l'interfaccia utente può essere fatto su un singolo thread - utilizzando il Backgroundworker in questo esempio. È solo l'elaborazione "complessa" che deve essere eseguita in modo parallelo (multi-thread). – RoadWarrior

Problemi correlati