Çoklu iş parçacığı Java

Herhangi bir uygulama birden fazla işleme (örnek) sahip olabilir. Bu işlemlerin her biri tek bir iş parçacığı veya birden fazla iş parçacığı olarak atanabilir. Bu eğitimde aynı anda birden fazla görevi nasıl gerçekleştireceğimizi göreceğiz ve ayrıca iş parçacıkları ve iş parçacıkları arasındaki senkronizasyon hakkında daha fazla bilgi edineceğiz.

Tek Konu Nedir?

Tek bir iş parçacığı Java temel olarak hafif ve en küçük işlem birimidir. Java "Thread Sınıfı" kullanarak thread'leri kullanır. İki tür thread vardır - kullanıcı iş parçacığı ve daemon iş parçacığı (daemon thread'ler uygulamayı temizlemek istediğimizde ve arka planda kullanıldığında kullanılır). Bir uygulama ilk başladığında, kullanıcı thread'i oluşturulur. Bunu takiben, birçok kullanıcı thread'i ve daemon thread'i oluşturabiliriz.

Tek Konu Örneği:

package demotest;

public class GuruThread
{
       public static void main(String[] args) {
              System.out.println("Single Thread");
       }
}

Tek ipliğin avantajları:

• Sistemde tek iş parçacığı yürütüldüğünden uygulamadaki yükü azaltır
• Ayrıca uygulamanın bakım maliyetini de azaltır.

Çoklu iş parçacığı örneği:

package demotest;
public class GuruThread1 implements Runnable
{
       public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Çoklu iş parçacığının avantajları:

• İş parçacıkları bağımsız olduğundan kullanıcılar engellenmiyor ve aynı anda birden fazla işlem gerçekleştirebiliyoruz
• İş parçacıkları bağımsız olduğundan, bir iş parçacığı bir istisnayı karşıladığında diğer iş parçacıkları etkilenmeyecektir.

Konu Yaşam Döngüsü Java

Bir iş parçacığının yaşam döngüsü:

Yukarıdaki diyagramda gösterildiği gibi ipliğin yaşam döngüsünün çeşitli aşamaları vardır:

1. yeni
2. çalıştırılabilir
3. Koşu
4. Bekleyen
5. ölü

1. Yeni: Bu aşamada “Thread class” sınıfı kullanılarak thread oluşturulur. Program bitene kadar bu durumda kalır. başlar iplik. Aynı zamanda doğmuş iplik olarak da bilinir.
2. Çalıştırılabilir: Bu sayfada iş parçacığının örneği bir start yöntemiyle çağrılır. İş parçacığı kontrolü, yürütmeyi bitirmek için zamanlayıcıya verilir. İş parçacığının çalıştırılıp çalıştırılmayacağı zamanlayıcıya bağlıdır.
3. Koşu: İş parçacığı yürütülmeye başladığında, durum "çalışıyor" durumuna değiştirilir. Zamanlayıcı, iş parçacığı havuzundan bir iş parçacığı seçer ve uygulamada yürütülmeye başlar.
4. Bekleyen: Bu, bir iş parçacığının beklemesi gereken durumdur. Uygulamada birden fazla iş parçacığı çalıştığı için, iş parçacıkları arasında senkronizasyona ihtiyaç vardır. Bu nedenle, bir iş parçacığının diğer iş parçacığı yürütülene kadar beklemesi gerekir. Bu nedenle, bu duruma bekleme durumu denir.
5. Ölü: Bu, iş parçacığının sonlandırıldığı durumdur. İş parçacığı çalışır durumdadır ve işlemeyi tamamlar tamamlamaz "ölü durumda" olur.

Çoklu İş Parçacığı Yöntemleri Java

Konular için yaygın olarak kullanılan yöntemlerden bazıları şunlardır:

Yöntem	Açıklama
Başlat()	Bu yöntem iş parçacığının yürütülmesini başlatır ve JVM iş parçacığında run() yöntemini çağırır.
Uyku(int milisaniye)	Bu yöntem iş parçacığının uykuya dalmasını sağlar, dolayısıyla iş parçacığının yürütülmesi belirli bir milisaniye boyunca duraklatılır ve bundan sonra iş parçacığı tekrar çalışmaya başlar. Bu iş parçacıklarının senkronizasyonuna yardımcı olur.
getName ()	İş parçacığının adını döndürür.
setPriority(int yeniöncelik)	İş parçacığının önceliğini değiştirir.
teslim olmak ()	Geçerli iş parçacığının durmasına ve diğer iş parçacıklarının yürütülmesine neden olur.

Örnek: Bu çok iş parçacıklı programda Java Örneğin, bir iş parçacığı oluşturacağız ve iş parçacıkları için kullanılabilen yerleşik yöntemleri inceleyeceğiz.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Kodun açıklaması:

• Kod Satırı 2: Runnable arayüzünü uygulayan bir “thread_Example1” sınıfı yaratıyoruz (örneklerinin iş parçacığı tarafından yürütülmesi amaçlanan herhangi bir sınıf tarafından uygulanmalıdır.)
• Kod Satırı 4: Bu yöntemin geçersiz kılınması zorunlu olduğundan, çalıştırılabilir arayüzün çalıştırma yöntemini geçersiz kılar
• Kod Satırı 6: Burada iş parçacığının yürütülmesine başlayacağımız ana yöntemi tanımladık.
• Kod Satırı 7: Burada yeni bir iş parçacığı sınıfını başlatarak “guruthread1” olarak yeni bir iş parçacığı adı oluşturuyoruz.
• Kod Satırı 8: “guruthread1” örneğini kullanarak iş parçacığının “start” yöntemini kullanacağız. Burada iş parçacığı yürütülmeye başlayacaktır.
• Kod Satırı 10: Burada “guruthread1” örneğini kullanarak iş parçacığının “sleep” yöntemini kullanıyoruz. Dolayısıyla iş parçacığı 1000 milisaniye boyunca uyuyacaktır.
• Kod 9-14: Burada try catch bloğuna uyku metodunu koyduk, çünkü kontrol edilen bir istisna var, yani Kesintili istisna.
• Kod Satırı 15: Burada iş parçacığının önceliğini, hangi öncelikten olursa olsun 1'e ayarlıyoruz.
• Kod Satırı 16: Burada getPriority() kullanarak iş parçacığının önceliğini alıyoruz.
• Kod Satırı 17: Burada getPriority'den alınan değeri yazdırıyoruz
• Kod Satırı 18: Burada iş parçacığının çalıştığı bir metin yazıyoruz.

Yukarıdaki kodu çalıştırdığınızda aşağıdaki çıktıyı alırsınız:

Çıktı:

5, Thread önceliğidir ve Thread Running, kodumuzun çıktısı olan metindir.

Java Konu Synckronizasyon

Çoklu iş parçacığında, programların eşzamansız davranışı vardır. Bir iş parçacığı veri yazıyorsa ve aynı anda veri okuyan başka bir iş parçacığı varsa, uygulamada tutarsızlık yaratabilir. Paylaşılan kaynaklara iki veya daha fazla iş parçacığı tarafından erişim ihtiyacı olduğunda, senkronizasyon yaklaşımı kullanılır. Java Eşzamanlı davranışı uygulamak için eşzamanlanmış yöntemler sağlamıştır.

Bu yaklaşımda, iş parçacığı senkronize bloğun içine ulaştığında, başka hiçbir iş parçacığı aynı nesne üzerinde o yöntemi çağıramaz. Tüm iş parçacıkları, o iş parçacığı senkronize bloğu bitirip oradan çıkana kadar beklemek zorundadır. Bu şekilde, senkronizasyon çok iş parçacıklı bir uygulamada yardımcı olur. Bir iş parçacığı, diğer iş parçacığının yürütmesini bitirmesini beklemek zorundadır, ancak o zaman diğer iş parçacıklarının yürütmesine izin verilir.

Aşağıdaki biçimde yazılabilir:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

Çoklu iş parçacığı Java Örnek Programlar

Bu çoklu iş parçacığında Java Örneğin, iki thread alacağız ve thread'in isimlerini getireceğiz.

Example1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Kodun açıklaması:

• Kod Satırı 3: Runnable'ı uygulayan bir "GuruThread1" sınıfı aldık (örneklerinin iş parçacığı tarafından yürütülmesi amaçlanan herhangi bir sınıf tarafından uygulanması gerekir).
• Kod Satırı 8: Bu sınıfın ana yöntemidir
• Kod Satırı 9: Burada Thread sınıfını başlatıyoruz ve “guruThread1” isimli bir örnek oluşturup thread oluşturuyoruz.
• Kod Satırı 10: Burada Thread sınıfını başlatıyoruz ve “guruThread2” adında bir örnek oluşturup bir thread oluşturuyoruz.
• Kod Satırı 11: Konuyu başlatıyoruz yani guruThread1.
• Kod Satırı 12: Konuyu başlatıyoruz yani guruThread2.
• Kod Satırı 13: Metni “İş parçacığı adları şunlardır:” şeklinde çıktı olarak verin.
• Kod Satırı 14: İş parçacığı sınıfının getName() yöntemini kullanarak iş parçacığı 1'in adını alma.
• Kod Satırı 15: İş parçacığı sınıfının getName() yöntemini kullanarak iş parçacığı 2'in adını alma.

Yukarıdaki kodu çalıştırdığınızda aşağıdaki çıktıyı alırsınız:

Çıktı:

Konu adları burada şu şekilde yayınlanıyor:

• Guru1
• Guru2

Örnek 2:

Bu çoklu iş parçacığında Java Örneğin, çalıştırılabilir bir arayüzün run() ve start() yöntemlerinin geçersiz kılınmasını öğreneceğiz ve o sınıftan iki iş parçacığı oluşturup bunları buna göre çalıştıracağız.

Ayrıca iki ders alıyoruz.

• Çalıştırılabilir arayüzü uygulayacak ve
• Ana yönteme sahip olacak ve buna göre yürütülecek bir tane daha.

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Kodun açıklaması:

• Kod Satırı 2: Burada ana metodun yer alacağı “GuruThread2” sınıfını alıyoruz.
• Kod Satırı 4: Burada sınıfın ana metodunu ele alıyoruz.
• Kod Satırı 6-7: Burada kodun aşağıdaki satırlarında oluşturulan GuruThread3 sınıfının bir örneğini “threadguru1” olarak oluşturuyoruz ve thread'i başlatıyoruz.
• Kod Satırı 8-9: Burada kodun aşağıdaki satırlarında oluşturulan GuruThread3 sınıfının bir örneğini “threadguru2” olarak oluşturuyoruz ve thread'i başlatıyoruz.
• Kod Satırı 11: Burada çalıştırılabilir arayüzü uygulayan bir “GuruThread3” sınıfı yaratıyoruz (örneklerinin iş parçacığı tarafından yürütülmesi amaçlanan herhangi bir sınıf tarafından uygulanmalıdır.)
• Kod Satırı 13-14: biri thread sınıfından ve diğeri string sınıfından olan iki sınıf değişkeni alıyoruz.
• Kod Satırı 15-18: guruname sınıf değişkenine atanan dize türü (iş parçacığı adıdır) olarak bir argüman alan ve dolayısıyla iş parçacığının adı saklanan GuruThread3 yapıcısını geçersiz kılıyoruz.
• Kod Satırı 20: Burada çalıştırılabilir arayüzün run() yöntemini geçersiz kılıyoruz.
• Kod Satırı 21: Println deyimini kullanarak iş parçacığı adının çıktısını alıyoruz.
• Kod Satırı 22-31: Burada, sayacın 0 olarak başlatıldığı bir for döngüsü kullanıyoruz ve 4'ten az olmamalıdır (herhangi bir sayıyı alabiliriz, dolayısıyla burada döngü 4 kez çalışacaktır) ve sayacı artırıyoruz. İş parçacığının adını yazdırıyoruz ve aynı zamanda iş parçacığının try-catch bloğu içinde 1000 milisaniye boyunca uyku moduna geçmesini sağlıyoruz, çünkü uyku yöntemi işaretli istisnayı kaldırdı.
• Kod Satırı 33: Burada çalıştırılabilir arayüzün başlatma yöntemini geçersiz kılıyoruz.
• Kod Satırı 35: “İş parçacığı başlatıldı” metnini çıkarıyoruz.
• Kod Satırı 36-40: Burada guruthread sınıf değişkeninin içinde değer olup olmadığını kontrol etmek için bir if koşulu alıyoruz. Eğer boşsa, o zaman adı parametre olarak alan (yapıcıda atanan değer) iş parçacığı sınıfını kullanarak bir örnek oluşturuyoruz. Bundan sonra iş parçacığı start() yöntemi kullanılarak başlatılır.

Yukarıdaki kodu çalıştırdığınızda aşağıdaki çıktıyı alırsınız:

Çıktı:

Dolayısıyla iki konu var, iki kez “Konu başlatıldı” mesajını alıyoruz.

İş parçacığının adlarını çıktı olarak alıyoruz.

Sayacı ve iş parçacığı adını yazdırdığımız for döngüsüne girer ve sayaç 0 ile başlar.

Döngü üç kez yürütülür ve iş parçacığı arasında 1000 milisaniye süreyle uyutulur.

Dolayısıyla, önce guru1'i, sonra guru2'yi, sonra tekrar guru2'yi elde ederiz çünkü iş parçacığı burada 1000 milisaniye boyunca uyur ve sonra sonraki guru1 ve yine guru1, iş parçacığı 1000 milisaniye uyur, böylece guru2'yi ve sonra guru1'i elde ederiz.

ÖZET

Bu eğitimde çok iş parçacıklı uygulamaları gördük. Java ve tek ve çoklu iş parçacığının nasıl kullanılacağı Java.

• Çoklu iş parçacığını açıklayın Java: Çoklu iş parçacığında, iş parçacıkları bağımsız olduğundan ve aynı anda birden fazla işlem gerçekleştirebildiğinden kullanıcılar engellenmez
• İpliğin yaşam döngüsünün çeşitli aşamaları şunlardır:
  • yeni
  • çalıştırılabilir
  • Koşu
  • Bekleyen
  • ölü
• Biz de şunları öğrendik senkronizasyon Uygulamanın sorunsuz çalışmasına yardımcı olan iş parçacıkları arasında.
• Çok iş parçacıklı programlama Java çok daha fazla uygulama görevini kolaylaştırır.