Multithreading i Java: Sådan kommer du i gang med tråde

Hvad er en tråd?

En tråd er en letvægtsproces. Enhver proces kan have flere tråde, der kører i den.

For eksempel i en webbrowser kan vi have en tråd, der indlæser brugergrænsefladen, og en anden tråd, som faktisk henter alle de data, der skal vises i den grænseflade.

Hvad er MultiThreading?

Multithreading giver os mulighed for at køre flere tråde samtidigt.

For eksempel i en webbrowser kan vi have en tråd, der håndterer brugergrænsefladen, og parallelt kan vi have en anden tråd, der henter de data, der skal vises.

Så multithreading forbedrer lydsystemets lydhørhed.

Hvad er samtidighed?

Samtidighed i sammenhæng med tråde giver os mulighed for at køre flere tråde på samme tid.

Men kører trådene virkelig på samme tid?

Single Core-systemer

Den Tråd Scheduler leveres af JVM afgør hvilken tråd kører på et givent tidspunkt. Planlæggeren giver en lille tidsskive til hver tråd.

Så til enhver tid har vi kun en tråd, der faktisk kører i processoren. Men på grund af tidsskæringen får vi en fornemmelse af, at flere tråde kører på samme tid.

Multi Core-systemer

Selv i flere kerne-systemer er trådplanlæggeren involveret. Men da vi har flere kerner, kan vi faktisk have flere tråde, der kører på nøjagtig samme tid.

For eksempel, hvis vi har et dual core-system, så kan vi have 2 tråde, der kører på nøjagtig samme tid. Den første tråd kører i den første kerne, og den anden tråd kører i den anden kerne.

Hvorfor er der behov for multithreading?

Multithreading gør det muligt for os at forbedre lydhørheden i et system.

For eksempel i en webbrowser, hvis alt kørte i en enkelt tråd, ville systemet ikke reagere fuldstændigt, når data blev hentet til visning. For eksempel, hvis det tager 10 sekunder at hente dataene, vil vi ikke i de 10 sekunder være i stand til at gøre noget andet i webbrowseren som at åbne nye faner eller endda lukke webbrowseren.

Så at køre forskellige dele af et program i forskellige tråde samtidigt hjælper med at forbedre lydhørheden i et system.

Sådan skriver du multitrådede programmer i Java

Vi kan oprette tråde i Java ved hjælp af følgende

  • Udvidelse af trådklassen
  • Implementering af den kørbare grænseflade
  • Implementering af den kaldbare grænseflade
  • Ved at bruge eksekveringsrammen sammen med kørbare og kaldbare opgaver

Vi vil se på callables og executor-rammen i en separat blog. I denne artikel vil jeg primært fokusere på at udvide trådklassen og implementere den kørbare grænseflade.

Udvidelse af trådklassen

For at skabe et stykke kode, der kan køre i en tråd, skaber vi en klasse og derefter udvide tråden klasse. Den opgave, der udføres af dette stykke kode, skal placeres i funktionen run () .

I nedenstående kode kan du se, at arbejdstager er en klasse, der udvider trådklassen , og opgaven med at udskrive numre 0 til 5 udføres inden for funktionen run () .

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

I ovenstående kode bruges Thread.currentThread (). GetName () til at få navnet på den aktuelle tråd, der kører koden.

For at oprette en tråd er vi bare nødt til at oprette en forekomst af arbejderklassen. Og så kan vi starte tråden ved hjælp af funktionen start () .

public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

I ovenstående kode opretter vi 3 tråde (t1, t2 og t3) fra arbejderklassen. Derefter starter vi trådene ved hjælp af start () -funktionen.

Her er den sidste kode til oprettelse af en tråd ved at udvide en trådklasse:

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Her er det output, vi får ved at køre ovenstående kode:

Trådklasse output

Du kan se, at alle de 3 tråde har udskrevet tallene fra 0 til 5.

Du kan også tydeligt se fra output, at de 3 tråde ikke kører i nogen bestemt rækkefølge

Implementering af det kørbare interface

For at oprette et stykke kode, der kan køres i en tråd, opretter vi en klasse og implementerer derefter den kørbare grænseflade. Den opgave, der udføres af dette stykke kode, skal placeres i funktionen run () .

I nedenstående kode kan du se, at RunnableWorker er en klasse, der implementerer kørbar grænseflade, og opgaven med at udskrive numre 0 til 4 udføres inde i funktionen run () .

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

For at oprette en tråd skal vi først oprette en forekomst af RunnableWorker, der implementerer den kørbare grænseflade.

Then we can create a new thread by creating an instance of the thread class and passing the instance of RunnableWorker as the argument. This is shown in the code below:

public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

The above code creates a runnable instance r. Then it create 3 threads (t1, t2 and t3) and passes r as the argument to the 3 threads. Then the start() function is used to start all 3 threads.

Here is the complete code for creating a thread by implementing the runnable interface:

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

On running the above code, we will get the following output. The sequence of the output will change every time the code is run.

Kørbar interface-udgang

Implementing the runnable interface is a better option than extending the thread class since we can extend only one class, but we can implement multiple interfaces in Java.

Runnable Interface in Java 8

In Java 8, the runnable interface becomes a FunctionalInterface since it has only one function, run().

The below code shows how we can create a runnable instance in Java 8.

public class RunnableFunctionalInterfaceDemo { public static void main(String[] args) { Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

Here, instead of creating a class and then implementing the runnable interface, we can directly use a lambda expression to create a runnable instance as shown below:

Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; 

Code

The code in this article is available in the following GitHub repo: //github.com/aditya-sridhar/basic-threads-demo

Congrats ?

You now know how to create threads by extending the thread class and by implementing the runnable interface.

I will discuss the thread life cycle and challenges while using threads in my next blog post.

My Website: //adityasridhar.com/

Du er velkommen til at oprette forbindelse til mig på LinkedIn eller følge mig på Twitter