C# WinForm Multithread-Entwicklung (1) Thread-Klassenbibliothek

Ursprüngliche Adresse: Klicken Sie hier, um den Link zu öffnen

[Zusammenfassung]Dieser Artikel stellt C# vor Thread-Klassenbibliothek für die WinForm-Multithread-Entwicklung und bietet einfachen Beispielcode als Referenz.

Windows ist ein Multitasking-System. Wenn Sie Windows 2000 und höher verwenden, können Sie den Task-Manager verwenden Prozesse, die derzeit auf dem System ausgeführt werden. Was ist ein Prozess? Wenn ein Programm ausgeführt wird, handelt es sich um einen Prozess. Der Prozess bezieht sich auf das laufende Programm und die vom Programm verwendeten Speicher- und Systemressourcen. Ein Prozess besteht aus mehreren Threads. Jeder Thread verfügt über ein eigenes privates Register (Stapelzeiger, Programmzähler usw.), aber der Codebereich wird gemeinsam genutzt, dh verschiedene Threads können ausgeführt werden die gleiche Funktion. Multithreading bedeutet, dass ein Programm mehrere Ausführungsströme enthält, d. h. mehrere verschiedene Threads können gleichzeitig in einem Programm ausgeführt werden, um unterschiedliche Aufgaben auszuführen. Dies bedeutet, dass ein einzelnes Programm mehrere parallele Ausführungsthreads erstellen darf, um ihre jeweiligen Aufgaben auszuführen.

1 Ein Hinweis zu Thread

In der .net Framework-Klassenbibliothek werden alle Klassen, die sich auf Multithreading-Mechanismusanwendungen beziehen, im System.Threading-Namespace platziert. Es stellt die Thread-Klasse zum Erstellen von Threads, die ThreadPool-Klasse zum Verwalten von Thread-Pools usw. bereit. Darüber hinaus bietet es Mechanismen zur Lösung praktischer Probleme wie Thread-Ausführungsvereinbarungen, Deadlocks und Kommunikation zwischen Threads. Wenn Sie Multithreading in Ihrer Anwendung verwenden möchten, müssen Sie diese Klasse einbinden. Die Thread-Klasse verfügt über mehrere wichtige Methoden, die wie folgt beschrieben werden:

• Start(): Starten Sie einen Thread

• Sleep(int): Statische Methode, pausiert den aktuellen Thread für die angegebene Anzahl von Millisekunden

• Abort(): Wird normalerweise verwendet diese Methode Um einen Thread zu beenden

• Suspend(): Diese Methode beendet den unvollendeten Thread nicht, sie unterbricht nur den Thread und kann später wieder aufgenommen werden.

• Resume(): Setzt die Ausführung des Threads fort, der durch die Suspend()-Methode angehalten wurde

Thread Der Eingang ermöglicht es dem Programm, zu wissen, was dieser Thread tun soll. In C# wird der Thread-Eingang über den ThreadStart-Delegaten bereitgestellt, der auf die vom Thread auszuführende Funktion verweist Mit der Thread.Start()-Methode beginnt der Thread mit der Ausführung der Funktion, die ThreadStart darstellt oder auf die er zeigt. Die möglichen Werte von ThreadState in verschiedenen Situationen sind wie folgt:

• Abgebrochen: Der Thread wurde gestoppt

• AbortRequested: Die Thread.Abort()-Methode des Threads wurde aufgerufen, aber der Thread wurde noch nicht gestoppt

• Hintergrund: Der Thread befindet sich in der Hintergrundausführung, bezogen auf die Eigenschaft Thread.IsBackground

• Wird ausgeführt: Der Thread wird normal ausgeführt

• Gestoppt: Der Thread wurde gestoppt

• StopRequested: Der Thread wird zum Stoppen aufgefordert

• Unterbrochen: Der Thread wurde angehalten (in diesem Zustand kann er durch Aufruf der Resume()-Methode erneut ausgeführt werden)

• SuspendRequested: Der Thread beantragt die Suspendierung, aber es ist keine Zeit zum Antworten

• Unstarted: Thread.Start( ) wird nicht aufgerufen, um die Ausführung des Threads zu starten

• WaitSleepJoin: Der Thread befindet sich aufgrund aufrufender Methoden wie Wait(), Sleep( ) oder Join()

Zwei in Winform verwendete Threads

Zunächst können Sie sich die direkteste Methode ansehen, Dies ist auch die Methode, die unter .net 1.0 unterstützt wird. Bitte beachten Sie jedoch, dass diese Methode nach .net 2.0 bereits eine falsche Methode ist.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    private void Form1_Load(object sender, EventArgs e)
    {
        Thread thread = new Thread(ThreadFuntion);
        thread.IsBackground = true;
        thread.Start();
    }
    private void ThreadFuntion()
    {
        while (true)
        {
            this.textBox1.Text = DateTime.Now.ToString();
            Thread.Sleep(1000);
        }
    }
}

Dieser Code löst eine Ausnahme auf vs2005 oder 2008 aus: Cross-Thread-Vorgang ungültig: Steuerelement „textBox1“, auf das von einem anderen Thread als dem Thread zugegriffen wird Es wurde am erstellt. Dies liegt daran, dass der Sicherheitsmechanismus nach .net 2.0 verstärkt wurde, was keinen direkten Thread-übergreifenden Zugriff auf die Eigenschaften des Steuerelements in Winform ermöglicht. Wie lässt sich dieses Problem lösen? Hier sind mehrere Lösungen.

Erste Lösung: Setzen Sie Control.CheckForIllegalCrossThreadCalls auf false, wenn Thread erstellt wird. Dieser Code teilt dem Compiler mit: In dieser Klasse prüfen wir nicht, ob Thread-übergreifende Aufrufe zulässig sind (wenn es bei der Ausführung ohne Hinzufügen dieses Satzes keine Ausnahme gibt, bedeutet dies, dass das System standardmäßig die nicht prüfende Methode übernimmt). Allerdings ist dieser Ansatz nicht ratsam. Wenn wir uns die Definition der CheckForIllegalCrossThreadCalls-Eigenschaft ansehen, werden wir feststellen, dass sie statisch ist, was bedeutet, dass sie unabhängig von der Stelle im Projekt, an der wir diesen Wert ändern, global wirksam wird. Und wir prüfen normalerweise, ob es bei solchen Cross-Thread-Zugriffen Ausnahmen gibt. Wenn andere im Projekt dieses Attribut ändern, schlägt unsere Lösung fehl und wir müssen eine andere Lösung übernehmen.

Zweite Lösung

namespace TestInvoker
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread = new Thread(new ThreadStart(StartSomeWorkFromUIThread));
            thread.IsBackground = true;
            thread.Start();
            //StartSomeWorkFromUIThread();
            //label1.Text = "Set value through another thread!";
        }
        private void StartSomeWorkFromUIThread()
        {
            if (this.InvokeRequired)
            {
                BeginInvoke(new EventHandler(RunsOnWorkerThread), null);
            }
            else
            {
                RunsOnWorkerThread(this, null);
            }
        }
        private void RunsOnWorkerThread(object sender, EventArgs e)
        {
            Thread.Sleep(2000);
            label1.Text = System.DateTime.Now.ToString();
        }
    }
}

Anhand des obigen Codes können Sie erkennen, dass das Problem vorliegt Gelöst Durch das Warten auf Asynchronität behalten wir nicht immer die Kontrolle über den Hauptthread, sodass die Multithread-Steuerung der WinForm-Multithread-Steuerung ohne Thread-übergreifende Aufrufausnahmen abgeschlossen werden kann.

Das Obige ist der Inhalt der C#-WinForm-Multithread-Entwicklung (1) Thread-Klassenbibliothek. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (m.sbmmt.com). )!