Пытается написать класс, который позволяет что-то сделать до начала Thread и после завершения Thread.

Question

Я пытаюсь написать класс Utility, который помогает выполнить задачу в отдельном потоке, предоставляя возможность что-то сделать перед задачей начинается, и что-то после завершения задачи.

Нечто подобное AsyncTask

Вот такой класс андроида.

class MySync 
{ 
    public void preExecute() {} 

    public void executeInBackground() {} 

    public void postExecute() {} 

    public final void execute() 
    { 
     threadExecute.start(); 
    } 

    private final Thread threadExecute = new Thread() 
    { 
      @Override 
      public void run() 
      { 
       try 
       { 
        MySync.this.preExecute(); 
        MySync.this.executeInBackground(); 
        MySync.this.postExecute(); 

       } 
       catch(Exception ex) 
       { 
        ex.printStackTrace(); 
       } 
      } 
    }; 
} 

Вот как этот класс предполагается использовать. Потребитель класса переопределит методы в соответствии с требованием.

class RegisterStudent extends MySync 
{ 
    @Override 
    public void preExecute() 
    { 
     System.out.println("Validating Student details. Please wait..."); 
     try 
     { 
      Thread.sleep(2000); 
     } 
     catch(Exception ex) 
     { 
      ex.printStackTrace(); 
     } 
    } 

    @Override 
    public void executeInBackground() 
    { 
     System.out.println("Storing student details into Database on Server. Please wait..."); 
     try 
     { 
      Thread.sleep(4000); 
     } 
     catch(Exception ex) 
     { 
      ex.printStackTrace(); 
     } 
    } 

    @Override 
    public void postExecute() 
    { 
     System.out.println("Student details saved Successfully."); 
    } 
} 

И, наконец, начинает задание:

public class AsyncDemo 
{ 
    public static void main(String... args) 
    { 
     new RegisterStudent().execute(); 
    } 
} 

Это, кажется, работает хорошо. Мой вопрос в том, является ли это правильным способом достижения цели, как указано в названии? Любые предложения о том, как это можно реализовать?

Answer 1

Что мне не нравится с вашим подходом является то, что вы создаете новый нить каждый раз, когда вы создаете новый экземпляр MySync, который не является масштабируемым, если вы намереваетесь создать много экземпляров вашего объекта, и это дорого стоит создать поток, если бы я был вами, я бы использовал исполнителя, чтобы ограничить общий количество потоков, выделенных для выполнения т спрашивает асинхронно, вот как вы можете это сделать, если вы хотите использовать только одну нить:

ExecutorService executor = Executors.newFixedThreadPool(1); 

Я также хотел бы вновь написать свой код что-то вроде этого:

public abstract class MySync implements Runnable { 
    @Override 
    public final void run() { 
     try { 
      preExecute(); 
      executeInBackground(); 
     } finally { 
      postExecute(); 
     } 
    } 
    protected abstract void preExecute(); 

    protected abstract void executeInBackground(); 

    protected abstract void postExecute(); 
} 

Таким образом, можно определить вся логика для всех реализаций.

Затем вы можете представить свою задачу так:

executor.submit(new RegisterStudent()); 

Answer 2

Погрузчик - именно то, что вы ищете. Вот введение для загрузчика

https://developer.android.com/guide/components/loaders.html
https://developer.android.com/reference/android/content/Loader.html

Answer 3

Что плохого в том, что вы заставляете пользователей расширить свой класс. В java вы можете расширить только 1 класс. Таким образом, структура не должна отнимать это.

Скорее использовать интерфейс:

public interface AsyncTask { 
    public default void preExecute() {} 

    public default void executeInBackground() {} 

    public default void postExecute() {} 
} 

И у пользователей передать, что к классу полезности:

class MySync 
{ 
    private AsyncTask task; 

    public MySync(AsyncTask task) { 
     this.task = task; 
    } 

    public final void execute() 
    { 
     threadExecute.start(); 
    } 

    private final Thread threadExecute = new Thread() 
    { 
      @Override 
      public void run() 
      { 
       try 
       { 
        MySync.this.task.preExecute(); 
        MySync.this.task.executeInBackground(); 
        MySync.this.task.postExecute(); 

       } 
       catch(Exception ex) 
       { 
        ex.printStackTrace(); 
       } 
      } 
    }; 
}