Bilişim Kitap İncelemeleri- 6

pandora sitesinden kitap ile ilgili bilgilere ulaşabilirsiniz.

Yayınlanma Tarihi:  2007
Satın Aldığım Tarih:  Şubat 2008

Kitap Hakkındaki Yorumum: 

Beni Javacı yapan kitap! Kitabın dili ingilizcedir. İngilizceniz yoksa bile bu kitabı alıp kodlarına baksanız, resimlerini inceleseniz bu kitaptan birşeyler kaparsınız…  Gerçekten JAVA’da temel şeyleri öğretebilen, farkları anlatabilen, mükemmel örnekler sunabilen bir kitap. Benim tavsiyem, kitabı aldığınızda (konuları bilseniz bile) bu kitabı en baştan incelemeye başlamanız. Yazar, kitabın 5. chapter’inde anlatmış olduğu bir örneği 16. veya 20. chapterlarda değinebiliyor. Mesela hemen hemen her konunun sonunda yer verdiği ve içerisine o konudan birşeyler kattığı ATM isimli örneği gerçekten çok güzel. Eğer Java ile karşılaşacağınız her koda en azından göz aşinalığınız olsun istiyorsanız, neredeyse baştan sonra satır satır okuduğum bu kitabı tavsiye ediyorum.

İnternet üzerinde bu konuyu işleyen ilk ve tek Türkçe dökümandır. Türk yazılımcı kardeşlerime yararlı olması dileği ile…

Multi-threading uygulamalarımızda Swing kullanacağımız zaman dikkat edilmesi gereken 2 nokta var.

1- Zaman alan işlemlerin Event Dispatch Thread üzerinde koşturulmaması gerekir. Aksi takdirde programımız işlem yaparken yanıt veremez hale gelecektir.

2- Programımızda Swing ile ilgili kullanmış olduğumuz tüm componentlerin Event Dispatch Thread üzerinden koşturulması.

Yukarıdaki veriler ışığında şu sonuç ortaya çıkıyor:

Programımız için Swing componentlerini kullanan bir GUI tasarladığımızda, bize en az 2 adet Thread lazım. 1 Thread’i uzun zaman alacak işlemlerimiz için kullanacağız, diğer Thread’imizide yani Event Dispatch Thread ‘inide tüm GUI bileşenleri için kullanacağız. Zaman alan işlemlerimiz programın arka tarafında çalışıp, işlemini tamamladığında GUI’mizi update edecek. Ve sonuç olarak kusursuz işleyen becerekli bir programa sahip olacağız.

SwingWorker’ın yapısında bulunan metodlar:

doInBackground():Uzun süren işlemlerin / hesaplamaların yapılacağı zaman çağırılacak thread.

done(): doInBackground() dan gelen sonuçları Event Dispatch Thread üzerinde koşturur.

execute(): SwingWorker objesinde bir threadi çalıştırmak için çağırdığımız metod.

get(): Programımız tarafından yapılan hesap işleminin tamamlanmasını bekler ve hesap işleminden çıkan sonucu döndür.

publish(): doInBackground() metodundan gelen orta sonuçları Event Dispatch Thread tarafında koşturulması için gönderir.

process (): publish()metodundan gelen orta sonuçları alır ve Event Dispatch Thread tarafında koşturulması için gönderir.

setProgress(): Thread’imizle ilgili ara değerler göndermek için kullanıyoruz. Genelde Progress bar’ı update ederken kullanıyor.

Şimdi basit bir örnek ile inceleyelim. Yapacağımız örneği genel olarak açıklayacak olursak; Örnektekteki programımız 2 classdan oluşuyor. Fibonacci sayılarının nasıl bulunduğunu göreceğiz. FibonacciCalculator classı swingWorker’ımızın çalışacağı alan ve GUI classıda isminden de anlaşılabileceği üzere Kullanıcı arayüzünün bulunduğu kısım. Şimdi dilerseniz kodlara ve içerisinde yorumlara göz atalım..

Class FibonacciCalculator

Class GUI

Hazırladığımız Programın Ekran Görüntüleri:

Ekran Görüntüsü – 1

Ekran Görüntüsü – 2

Ekran Görüntüsü – 3

Kodlar açık olduğun satır satır açıklamada bulunmuyorum, örneğin orjinal halini daitelin kitabından bulabilirsiniz. açıklama gerekebileceğini düşündüğüm yerlerede kod içerisinde comment olarak gerekli açıklamaları yaptım.

Soru, görüş ve önerilerinizi bekliyorum… yazan: Mustafa Ferhan Akman

İnternet üzerinde bu konuyu işleyen ilk ve tek Türkçe dökümandır. Türk yazılımcı kardeşlerime bir faydam olması dileği ile… 

Multi-threading uygulamalarımızda Swing kullanacağımız zaman dikkat edilmesi gereken 2 nokta var.

1- Zaman alan işlemlerin Event Dispatch Thread üzerinde koşturulmaması gerekir. Aksi takdirde programımız işlem yaparken yanıt veremez hale gelecektir.

2- Programımızda Swing ile ilgili kullanmış olduğumuz tüm componentlerin Event Dispatch Thread üzerinden koşturulması.

Yukarıdaki veriler ışığında şu sonuç ortaya çıkıyor:
Programımız için Swing componentlerini kullanan bir GUI tasarladığımızda, bize en az 2 adet Thread lazım. 1 Thread’i uzun zaman alacak işlemlerimiz için kullanacağız, diğer Thread’imizide yani Event Dispatch Thread ‘inide tüm GUI bileşenleri için kullanacağız. Zaman alan işlemlerimiz programın arka tarafında çalışıp, işlemini tamamladığında GUI’mizi update edecek. Ve sonuç olarak kusursuz işleyen becerekli bir programa sahip olacağız.

SwingWorker’ın yapısında bulunan metodlar:

doInBackground():Uzun süren işlemlerin / hesaplamaların yapılacağı zaman çağırılacak thread.

done(): doInBackground() dan gelen sonuçları Event Dispatch Thread üzerinde koşturur.

execute(): SwingWorker objesinde bir threadi çalıştırmak için çağırdığımız metod.

get(): Programımız tarafından yapılan hesap işleminin tamamlanmasını bekler ve hesap işleminden çıkan sonucu döndür.

publish(): doInBackground() metodundan gelen orta sonuçları Event Dispatch Thread tarafında koşturulması için gönderir.

process (): publish()metodundan gelen orta sonuçları alır ve Event Dispatch Thread tarafında koşturulması için gönderir.

setProgress(): Thread’imizle ilgili ara değerler göndermek için kullanıyoruz. Genelde Progress bar’ı update ederken kullanıyor.

Şimdi basit bir örnek ile inceleyelim.
Yapacağımız örneği genel olarak açıklayacak olursak; Örnektekteki programımız 2 classdan oluşuyor.
Fibonacci sayılarının nasıl bulunduğunu göreceğiz. FibonacciCalculator classı swingWorker’ımızın çalışacağı alan ve GUI classıda isminden de anlaşılabileceği üzere Kullanıcı arayüzünün bulunduğu kısım. Şimdi dilerseniz kodlara ve içerisinde yorumlara göz atalım..

Class FibonacciCalculator

Class GUI

Hazırladığımız Programın Ekran Görüntüleri:

Ekran Görüntüsü – 1

Ekran Görüntüsü – 2

Ekran Görüntüsü – 3

Kodlar açık olduğun satır satır açıklamada bulunmuyorum, açıklama gerekebileceğini düşündüğüm yerlerede kod içerisinde comment olarak gerekli açıklamaları yaptım.

Soru, görüş ve önerilerinizi bekliyorum…

yazan: Mustafa Ferhan Akman

JAVA SwingWorker ile uğraşıyorum.. ama bir yerde takıldım. Zira gerek elimdeki dökümanlar gerekse internetteki tüm dökümanlar (java.sun.com dahil) diyorlar ki;

bunun böyle çalışabilme kabileyeti varmış.. fakat ben doInBackground() metodunu kullandığımda ise, Eclipse bana return type’ının sadece Object olabileceğini söylüyor. Bu durumda el mahkum olarak, return type’ı Object yapıyoruz ve göndereceğimiz veriyi de String retStr = String.valueOf(intNumber); komutu ile String’e çevirip return retStr; diyerek return değerimizi gönderiyoruz.

After showing some problems with the synchronous solutions like Foxtrot or Spin. Now I want to talk about Swing Application Framework’s TaskService or a small own solution.

The Swing Application Framework uses annotated methods which can be executed as during the actionPerformed() method of an Action. The method can return a task to indicate that it needs to be executed in the background. This Task object is handed over to the TaskService which executes it in a background thread, like a SwingWorker. The Task object might have a blocking scope that defines how much of the user interface is blocked during execution. This is quite easy and works very well.

My problem is the Task class which not only contains information about how to block, but also the responsibility to create the blocker and a reference to the task service. If there are multiple tasks it might be possible that two blockers show a dialog . I would like to have a Task which is small and easy, like a command object from the command pattern. The command or task should then be handed over to the so called TaskService and this one should execute it.

First the Task needs to be simplified. Therefore the responsibility of creating and maintaining the InputBlocker moves over to the TaskService. The service has a single input blocker which is used in the complete application. So it has a unique interface and can also show a list of running tasks like the ProgressView of Eclipse. The service also should implement the Executor interface which makes it possible that even Runnable objects can be executed over this service. The service distinguishes between a Runnable object and a Task and can use a default blocking behavior like blocking the complete application. If the TaskService extends ThreadPoolExecutor it is easy to implement input blocking by blocking either in execute() or beforeExecute() and unblocking in afterExecute().

The Task class is then a simple extension of SwingWorker with some visual attributes like title and description, running time. An important BlockingScope that defines how much is blocked and an optional source from which the input blocker is able to block the user interface.

The image shows possible classes for the simplified service. I renamed the Task to SwingWorkerExt because it is a simple extension of SwingWorker. The enumeration BlockingScope and the interface InputBlocker stays as in the SwingApplicationFramework. But instead of having an association between InputBlocker and SwingWorkerExt, the input blocker only works together with the executor. In this case the SwingThreadPoolExecutor is the service used to execute background operations. introducing events when a command is added, removed, executed or rejected also helps the application to better react in extrem conditions.

SwingWorker is useful when a time-consuming task has to be performed following a user-interaction event (for example, parsing a huge XML File, on pressing a Button). The most straightforward way to do it is :

 private Document doc;
 ...
 JButton button = new JButton("Open XML");
 button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
       doc = loadXML();
    }
 });

This will work, but unfortunately, the loadXML() method will be called in the same thread as the main Swing thread, so if the method needs time to perform, the GUI will freeze during this time.

package com.wsjoung.demo;
import javax.swing.SwingUtilities;

public abstract class SwingWorker {
    // see getValue(), setValue()
    private Object value;
    private Thread thread;

    private static class ThreadVar {
        private Thread thread;
        ThreadVar(Thread t) { thread = t; }
        synchronized Thread get() { return thread; }
        synchronized void clear() { thread = null; }
    }

    private ThreadVar threadVar;

    protected synchronized Object getValue() {
        return value;
    }

    private synchronized void setValue(Object x) {
        value = x;
    }

    public abstract Object construct();

    public void finished() {
    }

    public void interrupt() {
        Thread t = threadVar.get();
        if (t != null) {
            t.interrupt();
        }
        threadVar.clear();
    }

    public Object get() {
        while (true) {
            Thread t = threadVar.get();
            if (t == null) {
                return getValue();
            }
            try {
                t.join();
            }
            catch (InterruptedException e) {
                // propagate
                Thread.currentThread().interrupt();
                return null;
            }
        }
    }

    public SwingWorker() {
        final Runnable doFinished = new Runnable() {
           public void run() { finished(); }
        };

        Runnable doConstruct = new Runnable() {
            public void run() {
                try {
                    setValue(construct());
                }
                finally {
                    threadVar.clear();
                }

              SwingUtilities.invokeLater(doFinished);
            }
        };

        Thread t = new Thread(doConstruct);
        threadVar = new ThreadVar(t);
        t.start();
    }
}

SwingWorker.java

public class Task{
  public void go() {
      current = 0;
      final SwingWorker worker = new SwingWorker() {
          public Object construct() {
              return new ActualTask();
          }
      };
  }

  class ActualTask {
      ActualTask() {
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {}
      }
  }
}

Task.java