.NET - ist es besser, Async oder Thread für eine Funktion mit CPU und IO-Operationen zu verwenden?

Question

Ich habe eine Klasse mit einer Methode, die eine Menge IO macht. Ich muss diese Methode starten a Aber es muss auch CPU-Operationen zu überprüfen, wo Daten zu schreiben. Ist es besser, in diesem Fall eine Async-Funktion oder eine neue Aufgabe zu verwenden?

Der Code ist unten (VB.NET). Die Methode wird für jede "Messgröße" aufgerufen und die Messgrößen sind ~ 3000. Daten müssen so schnell wie möglich auf die Festplatte geschrieben werden. Außerdem werden Daten mit einer Rate von 50 pro Sekunde empfangen. Im Idealfall, wenn Daten einer Messgröße eintreffen, sollte sie auf die Platte geschrieben werden, ohne auf eine andere Messgröße zu warten und ihre Daten zu schreiben.

Public Sub saveMeasurand(ByVal measurand_id As String) 
    Dim meas_id As String = measurand_id 
    Dim datum As SortedDictionary(Of DateTime, String) 
    Dim save_meas_data As Boolean 
    Dim first_meas_data As Boolean 
    Dim first_ticks As Long 
    Dim last_date_meas As DateTime 
    Dim curr_date As DateTime 
    Dim last_ticks As Long 
    Dim curr_ticks As Long 
    Dim datum_ticks As Long 
    Dim row As String 
    Dim meas_path As String 

    datum = Me.data(meas_id) 

    Try 
     save_meas_data = Me.save_data(meas_id) 
    Catch ex As KeyNotFoundException 
     save_meas_data = True 
    End Try 

    If Not save_meas_data Then 
     Throw New Exception(
      "Can't save data for id '" & 
      meas_id & 
      "', resource is locked" 
     ) 
    End If 

    If Me.dt = 0 Then 

    End If 

    Try 
     Me.save_data(meas_id) = False 

     Try 
      first_meas_data = Me.first_data(meas_id) 
     Catch ex As KeyNotFoundException 
      first_meas_data = True 
     End Try 

     Dim datum_keys() As DateTime 
     datum_keys = datum.Keys.ToArray() 

     If datum_keys.Length < 1 Then 
      Throw New Exception("No data to save") 
     End If 

     If first_meas_data Then 
      first_ticks = datum_keys.First().Ticks 
     Else 
      first_ticks = Me.last_date(meas_id).Ticks + Me.dt 
     End If 

     last_date_meas = datum_keys.Last() 
     last_ticks = last_date_meas.Ticks 
     curr_ticks = first_ticks 

     For Each datum_date As DateTime In datum_keys 
      datum_ticks = datum_date.Ticks 

      While datum_ticks - curr_ticks > Me.dt_tolerance 
       curr_date = New DateTime(curr_ticks) 
       row = Me.nanDatum(curr_date, meas_id) 
       meas_path = Me.measurandPath(curr_date, meas_id) 

       Using writer As StreamWriter = File.AppendText(meas_path) 
        writer.WriteLine(row) 
       End Using 

       curr_ticks += Me.dt 
      End While 

      row = datum(datum_date) 
      meas_path = Me.measurandPath(datum_date, meas_id) 

      Using writer As StreamWriter = File.AppendText(meas_path) 
       writer.WriteLine(row) 
      End Using 

      Me.data(meas_id).Remove(datum_date) 
      curr_ticks += Me.dt 
     Next 

     Me.first_data(meas_id) = False 
     Me.last_date(meas_id) = last_date_meas 
    Catch ex As Exception 
     ' log me 
    Finally 
     Me.save_data(meas_id) = True 
    End Try 
End Sub 

Answer 1

haben eine Klasse mit einer Methode, die eine Menge von IO tut

Dann ist es ein IO-Betrieb gebunden und in einem solchen Fall sollten Sie erwägen, eine Asynchronous Methode und beste Art und Weise mit einem haben verwendet async - await.

Normalerweise sollten Sie die Operation in einem separaten Hintergrundthread ausführen, wenn es sich um eine CPU-gebundene Operation handelt, die mit mehr Berechnungen auf der CPU zu tun hat.