Was sind Prozesse und Threads?

1 Übersicht

1. Was ist ein Prozess?

Ein Prozess ist eine relativ unabhängige Ausführungseinheit.

2. Was ist ein Thread?

Ein Teil des Prozesses, der eigentliche Aufgabenausführer im Prozess, muss dem Prozess zugeordnet werden. Die Abhängigkeit von Threads von Prozessen spiegelt sich hauptsächlich wider in:

• Threads können nicht ohne den Prozess gestartet werden und müssen unter der Voraussetzung gestartet werden, dass der Prozess gestartet wird.

• Threads müssen manchmal Daten aus dem Prozess abrufen.

3. Was ist der Unterschied zwischen Threads und Prozessen?

Thread und Prozess sind zwei relative Konzepte in Bezug auf die Ausführungseinheit, zu der es gehört, wird als Thread bezeichnet.

4. Der Designzweck, die Verwendung und die Bedeutung von Multithreading

CUP kann zu jedem Zeitpunkt nur einen Thread ausführen -Threading Die Essenz besteht darin, dass mehrere Aufgaben abwechselnd mit hoher Geschwindigkeit ausgeführt werden. Wenn kein Datenaustausch zwischen mehreren Threads stattfindet, kann unabhängig voneinander ausgeführt werden. Durch die Verwendung von Multithreading kann die Gesamtausführungszeit nicht verkürzt werden.

Der Hauptzweck des Multi-Thread-Designs besteht nicht darin, die Ausführungsgeschwindigkeit zu erhöhen, sondern jeden Thread relativ gleichmäßig auszuführen, sodass ein bestimmter Thread die CPU-Zeitscheibe nicht für eine Weile hält Lange Zeit, Andere Threads warten schon lange. Da die CPU-Zeitscheibe schnell zwischen mehreren Threads wechselt, über den Bereich hinaus, den menschliche Sinne wahrnehmen können, fühlt es sich an, als würden mehrere Aufgaben ausgeführt.

Wenn beispielsweise mehrere Personen dieselbe Website besuchen, dauert es für jede Person 5 Minuten. Wenn kein Multithreading verwendet wird, darf nur eine Person gleichzeitig die Website betreten Gleichzeitig und die meisten anderen Leute Sie müssen 5 Minuten warten, die Benutzererfahrung ist sehr schlecht. Dies nutzt Multithreading, nachdem eine Person eingetreten ist, sodass andere Benutzer nacheinander eintreten können. Das Benutzererlebnis wird verbessert, obwohl die Gesamtausführungszeit nicht verkürzt wird.

5. CPU-Planungsmodus

• Time-Sharing-Planungsmodus: Das System weist jedem Thread CPU-Zeitscheiben zu gleichmäßig.

• Präventiver Planungsmodus: Jeder Thread konkurriert um CPU-Zeitscheiben, und CPU-Zeitscheiben werden ungleichmäßig auf die Threads verteilt.

Erstellung von zwei Threads

1. Die Java SE API bietet zwei Möglichkeiten zum Erstellen von Threads:

• Implementieren Sie die Runnable-Schnittstelle und übergeben Sie das Objekt der Implementierungsklasse als Parameter an den Konstruktor von Thread.

• erbt direkt die Thread-Klasse.

2. Unabhängig von der verwendeten Methode müssen die auszuführenden Aufgaben in der Ausführungsmethode platziert werden.

3. Der Unterschied zwischen den beiden Erstellungsmethoden:

⑴Java übernimmt die Einzelvererbung, dh eine Klasse kann nur eine übergeordnete Klasse erben , während eine Klasse mehrere Schnittstellen implementiert und Threads durch Erben von Threads erstellt, diese Klasse verliert ihre einzige Vererbungsmöglichkeit.

⑵Es gibt verschiedene Möglichkeiten, Ressourcenteilung zu realisieren

• Zunächst muss klar sein, dass Ressourcenteilung auch durch Vererbung erreicht werden kann Thread zum Erstellen eines Threads. Da es sich bei mehreren Threads, die über das Schlüsselwort new erstellt wurden, um unterschiedliche Objekte handelt, können gemeinsam genutzte Ressourcen nur von außen kommen und normalerweise über den Konstruktor injiziert werden.

• Durch die Implementierung der Runnable-Schnittstelle zum Erstellen von Threads können Sie

  mehrere Threads mit demselben Implementierungsklassenobjekt erstellen und so die gemeinsame Nutzung von Ressourcen realisieren. Gemeinsame Ressourcen kommen aus dem Thread.

4. Das Erstellen von Threads durch Implementierung der Runnable-Schnittstelle behält nicht nur die einzige Vererbungsmöglichkeit bei, sondern macht auch Ressourcenfreigabevorgänge relativ einfach, also im Allgemeinen

Erstellen Sie auf diese Weise Threads.

5. Realisieren Sie die gemeinsame Nutzung von Ressourcen durch Erben von Thread:

Externe Klassen, die gemeinsam genutzte Ressourcen bereitstellen

package com.test.thread.extendsThread;public class MyClass {public int count;

}

Thread-Thread-Unterklasse

package com.test.thread.extendsThread;public class MyThread extends Thread {private MyClass obj;public MyThread() {super();
    }public MyThread(MyClass obj) {super();this.obj = obj;
    }

    @Overridepublic void run() {
        System.out.println("obj=" + obj);while (true) {synchronized (obj) {if (obj.count > 0) {try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "----当前数量=" + obj.count--);
                } elsereturn;
            }
        }

    }

}

Testklasse

 

三 线程生命周期

1.什么是线程的生命周期？

由不同阶段构成的线程从出生到死亡的整个过程，叫做线程的生命周期。

2.线程生命周期的意义

了解线程的生命周期能够更好地掌握线程的运行情况，比如线程的就绪状态，意味着不是调用start方法之后，线程立即执行。

3.生命周期的几个阶段：

• 出生状态：线程创建完成，尚未开启前的状态。

• 就绪状态：调用start方法开启线程，线程尚未运行的状态。

• 运行状态：线程获取CPU时间片执行时的状态。

• 休眠状态：线程调用sleep方法后进入指定时长的休眠状态，时间结束进入就绪状态。

• 等待状态：监听对象在线程内部调用wait方法后，线程失去对象锁，进入等待状态。

• 阻塞状态：线程发出输入或者输出请求后进入阻塞状态。

• 死亡状态：run方法执行完毕，线程死亡。

四 线程的加入

一个线程A在另一个线程B内部调用join方法，B线程中止，A线程开始执行，A线程执行完毕，B线程才开始执行。

五 线程优先级

线程优先级设定了线程获取CPU时间片的概率，仅仅是一种概率，不能保证优先级高的线程一定优先获得CPU时间片。

线程优先级分为10个等级，从1-10，数值越大，优先级越高，通过setProprity（int）方法设置。

六 线程礼让

Thread.yield，线程礼让只是通知当前线程可以将资源礼让给其他线程，并不能保证当前线程一定让出资源。

七 同步机制

1.什么是线程同步机制？

使得同一资源同一时刻只能有一个线程访问的安全机制，即一个线程访问完毕，其他线程才能访问。

2.同步机制的目的

由于目标资源同一时刻只有一个线程访问，解决了线程安全问题。

3.什么是线程安全问题？

⑴线程安全问题产生条件

• 多线程并发访问。

• 存在可修改的共享数据。

⑵第一个线程获取了共享数据，操作结束前，第二个线程修改了该数据，导致第一个线程运算时采用的不是获取时的数据。

4.同步机制解决线程安全问题的原理

synchronized(共享对象){ 修改共享数据的代码 }

上述操作给修改共享数据的代码加了一把对象锁。任何一个对象只有一把对象锁，线程只有获得了对象锁才能访问加锁的资源。一个线程获取了对象锁，执行加锁的代码，执行完毕，归还对象锁，其他线程开始争夺对象锁，访问资源。

5.类锁

synchronized关键字加到静态方法上时，形成类锁，执行该方法上必须获取类锁。

类锁与对象锁是两种不同的锁，允许一个线程持有类锁，另一个线程持有对象锁。

6.synchronized关键字

synchronized关键字加在成员方法，该方法成为同步成员方法，由于一个对象只有一把对象锁，一个线程访问了一个同步成员方法，其他线程不能访问其他同步成员方法。

同步方法不可以被继承，同步方法在子类中失去同步机制。

7.判断条件的设置

在同步机制中，如果同步代码的执行需要满足一定条件，那么将判断条件放在锁内，保证当前获取了锁的线程在执行同步代码时满足执行条件。如果放在锁外，有可能出现当前线程获取了锁以后不满足执行条件的情况。

不存在线程安全问题的做法：

public void run() {
        System.out.println("obj=" + obj);while (true) {synchronized (obj) {if (obj.count > 0) {try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "----当前数量=" + obj.count--);
                } elsereturn;
            }
        }

    }

Wenn die Beurteilungsbedingung obj.count>0 in die while-Anweisung eingefügt wird, kann es vorkommen, dass die Anzahl 1 beträgt, wenn ein Thread in die while-Anweisung eintritt, die Bedingung erfüllt, eintritt und auf den Erwerb des Objekts wartet sperren. Wenn der Thread, der derzeit die Objektsperre hält, die Ausführung abschließt, wird die Anzahl 0 und der wartende Thread erhält die Objektsperre Wenn Anzahl = 0, führt den Synchronisationsblock aus und die Beurteilungsbedingung wird ungültig.

8 Deadlock

1. Was ist ein Deadlock?

Thread A benötigt mehrere Sperren, die A fehlen, und es fehlen die von A gehaltenen Sperren. Da der Thread die gehaltenen Sperren nicht freigibt, bevor er alle Sperren erhält , Dies führt dazu, dass Thread A und Thread B ins Stocken geraten und der gesamte Prozess stagniert.

2. Wie vermeide ich einen Deadlock?

Reduzieren Sie die Anzahl der Sperren im Synchronisierungsmechanismus und versuchen Sie zu vermeiden, dass dieselbe Sperre an mehreren Stellen auftritt.

Neun Daemon-Threads

1. Benutzer-Thread?

Im Allgemeinen handelt es sich bei den erstellten Threads um Benutzerthreads, d. h. der Thread ist nicht explizit als Daemon-Thread festgelegt und wird nicht innerhalb des Daemon-Threads erstellt.

2. Der Hauptthread gehört zum Benutzerthread.

3. Was ist ein Daemon-Thread?

Ein Thread, der im Hintergrund läuft und Dienste für Benutzer-Threads bereitstellt.

4. Daemon-Thread-Erstellung

Der Benutzer-Thread ruft die setDaemon(true)-Methode auf oder erstellt einen Thread innerhalb des Daemon-Threads.

5. Die Rolle des Daemon-Threads

Daemon-Thread wird verwendet, um Dienste für Benutzer-Threads bereitzustellen, z. B. Garbage Collector.

6. Die JVM wird beendet, nachdem alle Benutzer-Threads die Ausführung abgeschlossen haben, unabhängig davon, ob der Daemon-Thread zu diesem Zeitpunkt die Ausführung abgeschlossen hat.

7. Der Daemon-Thread läuft im Hintergrund und endet automatisch, nachdem alle Benutzer-Threads beendet sind.

Vergleich von Warte- und Schlafmethoden

1. Existenzbereich

• Die Wartemethode ist auf Objektebene, d. h. jedes Objekt in Java verfügt über diese Methode, z. B. toString.

• Die Sleep-Methode existiert nur in Thread und seinen Unterklassen.

2. Funktion

• sleep bewirkt, dass der aktuelle Thread in den Ruhezustand versetzt wird und die CPU freigegeben wird Gehaltene Sperren werden nicht aufgehoben.

• Warten wird für die Kommunikation zwischen Threads verwendet, und das Objekt verwaltet alle Threads, die das Objekt als Sperre verwenden. Der aktuelle Thread wird vom Sperrobjekt im Synchronisierungscode aufgerufen und gibt die von gehaltene Objektsperre frei.

3. Verwendung von

• Die Schlafmethode ist direkt eine statische Methode über Thread Call, Thread.sleep.

• wird im Synchronisationscode verwendet und vom Sperrobjekt aufgerufen.

4. Verwandte Methoden

• obj.notify(): Objekt zufällig aufwecken Überwachung Ein Thread auf dem Server wechselt in den Bereitschaftszustand. Sobald er die Objektsperre und die CPU-Zeitscheibe erhält, setzt er die Ausführung ab dem Wartepunkt fort. gibt die Ausführungsmethode oder den Synchronisierungscode nicht erneut ein.

• obj.notifyAll(): Weckt alle wartenden Threads auf dem Objekt-Listener auf und versetzt sie alle in den Bereitschaftszustand.

十一 ThreadLocal

1.线程局部变量，为每一个线程提供一个变量的副本，使得各个线程相对独立地操作变量，避免线程安全问题。

2.首先必须明确一点，ThreadLocal.get()获取的变量副本必须手动传入：

ThreadLocal.set(Object obj)

初次获取时，判断线程局部变量中是否保存有变量副本，如果没有则手动传入，在该线程中下次获取的就是初次传入的对象。

3.ThreadLocal的目的是保证在一个线程内部，一次创建，多次获取。

4.基本原理：
      将初次传入的变量与线程绑定，线程不变，变量不变。

十二 GroboUtils多线程测试

   1.JUnit测试不支持多线程，GroboUtils提供了对多线程测试的支持，使用时需要导入架包。

    2.几个比较重要的类：

• TestRunnable:实现了Runnable接口，run方法中运行的是runTest方法，runTest方法是一个抽象方法。

• MultiThreadedTestRunner:负责管理并开启多个线程。

    3.测试步骤

⑴继承TestRunnable，实现其中的抽象方法runTest，将需要运行的代码放入该方法中。通常为子类定义一个有参构造方法，方法形参为需要测试的线程，在runTest方法中调用测试线程的run方法，从而将将需要执行的代码注入runTest方法中。

⑵创建测试线程数组，将需要测试的TestRunnable实现类传入其中:

TestRunnable[] tr=new TestRunnable[len]；

⑶根据测试线程数组创建线程管理与运行对象并开启多线程:

MultiThreadedTestRunner mttr=new MultiThreadedTestRunner(tr);
mttr.runTestRunnables();

Das obige ist der detaillierte Inhalt vonWas sind Prozesse und Threads?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!