Einführung in das Verständnis und die Verwendung von Multithreading

1. Word-Teil:

①Prozess ②aktueller aktueller ③Thread Thread ④runnable verfügbar

⑤interrupt ⑥join ⑦erzeugter Ertrag ⑧synchronisieren erfolgt gleichzeitig

2. Vorschauteil

1. Der Unterschied zwischen Threads und Prozessen:

Prozess ist die Grundeinheit des Systemlaufprogramms

Thread ist die kleinste Einheit zum Ausführen von Vorgängen im Prozess

2 .Erklären Welche zwei Möglichkeiten gibt es, einen Thread zu erstellen?

①Die Thread-Klasse erben

②Die Runnable-Schnittstelle implementieren

3. jeweils Was sind die Phasen

Fünf Phasen: ①Erstellen ②Bereit ③Ausführen ④Blockieren ⑤Tod

4. Welche Methoden zur Verwendung von Threads können den Ruhezustand des Threads, die Durchsetzung des Threads und die Höflichkeit festlegen? der Thread?

sind: Sleep(), Join()

Unter welchen Umständen ist eine Thread-Synchronisierung erforderlich

Wenn Zugriffskonflikte auftreten,

muss auf zwei Arten vorgegangen werden: ① Synchronisierte Methode ② Synchronisierter Codeblock

3. Übungsteil

1 Erstellen Sie einen Thread mit a Methode, die die Thread-Klasse erbt, zeigt den entsprechenden Inhalt an

Erstellen Sie zunächst eine Thread-Klasse:

Paket oneOne;

öffentliche Klasse MyRunnableone erweitert Thread{

public void run() {
for(int i=1;i<=20;i++){
System.out.println(i+".Hallo, aus Thread"+Thread.currentThread().getName( ));

}
}

Erstellen Sie die Hauptmethodenklasse erneut und entfernen Sie sie

package oneOne;

public class testone {

/**

* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
MyRunnableone my=new MyRunnableone ();
MyRunnableone my1 =new MyRunnableone();
my.start();
my1.start();
}

}

2 . Erstellen Sie einen Thread, indem Sie die Runnable-Schnittstelle implementieren

Wie beim ersten, erstellen Sie zuerst die Implementierungsklasse:

Paket oneTwo;

öffentliche Klasse MyRunnabletwo implementiert Runnable{

public void run() {
for(int i=1;i<=20;i++){
System.out.println(i+".Hallo, aus Thread"+Thread.currentThread( ).getName());

}
}

}

Remain-Methode:

package oneTwo;

public class testtwo {

/**

* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
MyRunnabletwo my =new MyRunnabletwo();
MyRunnabletwo my1=new MyRunnabletwo();
Thread tr=new Thread(my);
Thread tr1=new Thread(my1);
tr.start();
tr1.start();
}

}

3. Verwenden Sie Multithreading, um das Wandern und Klettern für mehrere Personen zu simulieren

Erstellen Sie zunächst eine Vererbung oder Implementierungsklasse (ich habe hier Vererbung verwendet):

package oneThree;

public class MyRunnable three erweitert Thread{

private int time;
public int num=0;
public MyRunnable three(String name,int time,int kio) {
super(name);
this.time=time;
this.num=kio*1000/100;

}
public void run() {

while (num>0) {
try {
Thread.sleep(this.time);
} Catch (InterruptedException e) {
// TODO: Ausnahme behandeln
e.printStackTrace ();
}
System.out.println(Thread.currentThread().getName()+"100 Meter geklettert! ");

num--;
}
System.out.println(Thread.currentThread().getName()+"Am Ende angekommen!");
}

}

Remain-Methode:

Paket einsDrei;

öffentliche Klasse testdrei {

/**

* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
MyRunnable three young=new MyRunnable three("young man", 500, 1);
MyRunnable three old=new MyRunnable three ( "Elderly", 1500, 1);
MyRunnable three child=new MyRunnable three("Child", 600, 1);
System.out.println("************ Fangen Sie an, den Berg zu erklimmen *********");
old.start();
young.start();
child.start();
}

}

4. Anzeigen, Thread-Priorität festlegen

Erben oder implementieren Sie zuerst die Klasse:

Paket oneFour;

öffentliche Klasse MyRunnablefour erweitert Thread {

public void run() {
Thread.currentThread().setPriority(1);
System.out.println("Sub-thread name: "+Thread.currentThread().getName() +", Priority : "+Thread.currentThread().getPriority());
}
}

Then main:

package oneFour;

öffentlicher Klassentestvier {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
MyRunnablefour myf=new MyRunnablefour();
myf.start();
System.out.println("********************Standardpriorität anzeigen********");
System .out .println("Haupt-Thread-Name: "+Thread.currentThread().getName()+", Priorität: "+Thread.currentThread().getPriority());
Thread.currentThread().setPriority( 10 );
System.out.println("**************************** nach Änderung der Standardpriorität");
//myf.setPriority (1);
System.out.println("Haupt-Thread-Name: "+Thread.currentThread().getName()+", Priorität: "+Thread.currentThread().getPriority ());
//System.out.println("Sub-Thread-Name: "+MyRunnablefour.currentThread().getName()+", Priorität: "+MyRunnablefour.currentThread().getPriority());


}

}

5. Simulieren Sie das Anrufen einer Nummer und einen Arztbesuch

Erben oder implementieren Sie zuerst die Klasse:

package oneFive;

public class MyRunnable five erweitert Thread{
private int time;
//public int pertail=0;
public MyRunnable five(String common,int time) {
super(common);
this. time=time;

}
public void run() {
Thread.currentThread().setPriority(8);
for( int i=1;i<=10;i++ ){
try {
Thread.sleep(this.time);
} Catch (InterruptedException e) {
// TODO: Ausnahme behandeln
e.printStackTrace();
}
System.out.println("Spezielle Nummer: „+i+“ Patient geht zum Arzt! ");

}
}

}

Remain:

package oneFive;

public class test five {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Automatisch generierter Methoden-Stub
//MyRunnabletwo pertail=new MyRunnabletwo(" Special number", 1000);

Thread temp=new Thread(new MyRunnable five("Special number", 400));
temp.start();
Thread.currentThread().setPriority ( 4);
for(int i=1;i<=50;i++){

if(i==11){

try {
temp.join ( );
} Catch (InterruptedException e) {
// TODO: Ausnahme behandeln
e.printStackTrace();
}
}
try {
Thread.sleep ( 200);
} Catch (InterruptedException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
System.out.println("Normale Zahl : „+i+“ Patient wird behandelt“);

}

}
}

6. Multithread-Simulationsstaffellauf

Zuerst Erstellen Sie eine Vererbungs- oder Implementierungsklasse:

package oneSix;

public class runSix implementiert Runnable{
private int meter=1000;
public runSix(){


}
@Override
public void run() {
// TODO Automatisch generierter Methoden-Stub
//System.out.println("Coming in");
while (true) {
//type type = (type) true.nextElement();
synchronisiert (this) {
if(meters<=100){
break;

}
System.out.println(Thread.currentThread().getName()+" Habe den Staffelstab! ");
for (int i = 0; i < 100; i+=10) {
try {
Thread.sleep(100);
} Catch (InterruptedException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"ran"+(i+10 ) +"Meter!");
}
Meter-=100;
}
}
}

}

Dann Hauptschnittstellenklasse:

package oneSix;

public class testsix {

/**
* @param args
*/
public static void main(String[] args) {
/ / TODO Automatisch generierter Methoden-Stub
runSix ru=new runSix();
for (int i = 0; i < 5; i++) {
new Thread(ru,(i+1) + "Spieler-Nr.".start();
}
}

}

7. Multi-Thread-Simulation des Online-Ticketkaufs

Taopaopao, Zhang stimmt ab, Scalper, zehn Stimmen zusammen holen, Scalper auf nur ein Ticket beschränken

Erstellen Sie zuerst eine Vererbungs- oder Implementierungsklasse:

Paket oneSeven;

öffentliche Klasse siteSeven implementiert Runnable{
private int count=10;
private int num=0;
private boolean flag=false;

@Override
public void run () {
// TODO Automatisch generierter Methoden-Stub
//System.out.println("Coming in");
while (!flag) {

synchronisiert (this) {
//System.out.println("Coming in");
if(count<=0){
flag=true;
return;
}
num++;
count--;
try {
Thread.sleep(500);
} Catch (InterruptedException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace( );
}
String name=Thread.currentThread().getName();
if(name.equals("scalper")){
System.out.println(name+"rob The „+num+“tes Ticket ist erreicht, und „+count+“ Tickets verbleiben! +count+“ verbleibende Tickets! package oneSeven;

public class testseven {

/**
* @param args
*/
public static void main(String[] args) {

// TODO Automatisch generiert method stub

siteSeven si=new siteSeven();

Thread per1=new Thread(si,"Dadong");

Thread yellow=new Thread(si,"Scalper");

Thread per2 =new Thread(si,"Qizhen");

per1.start();

yellow.start();

per2.start();

}

}

Viertens: Zusammenfassung:

1. Die Methoden in der Thread-Klasse implementieren Operationen an Thread-Objekten

①Passen Sie die Priorität des Threads an

②Thread-Sleep-Sleep( )

③Thread erzwungenes Ausführen von join()

④Thread mit freundlicher Genehmigung von yield()

2. Mit Multithreading können Programmierer Programme schreiben, die die Nutzung des CPU-effizienten Programms maximieren 🎜>

3. Zwei Möglichkeiten, Threads zu erstellen:

①Deklarieren Sie eine Unterklasse, die die Thread-Klasse erbt, und implementieren Sie die run()-Methode der Thread-Klasse.

②Deklaration Eine Klasse, die die Thread-Klasse implementiert Ausführbare Schnittstelle und implementiert dann die run()-Methode

Das obige ist der detaillierte Inhalt vonEinführung in das Verständnis und die Verwendung von Multithreading. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!