Multithreading cet exemple de code:

Question

Donc voici un code sur http://groups.google.com/group/android-developers/browse_thread/thread/16a2216b39513674 dans lequel l'affiche écrit qu'il a raccourci des idées dans une seule application fileté. Un répondant au-dessous de son poste dit, essentiellement, que c'est un excellent travail, mais qu'il y a des avantages à faire du multithread pour que les choses n'interfèrent pas avec d'autres choses sur votre téléphone.

Ma question est: De toute évidence, l'affiche originale réduite, les idées distillées à partir d'exemples multithread qu'il a vu afin de les rendre plus faciles à lire, posté, cool. Mais à quoi ressemblerait une version multithread du code ci-dessous?

Est-ce que Runnable serait sur un thread séparé? Ou tout le rappel? Ou pas ceux mais quelque chose d'autre? Rien d'autre?

Serait-ce encore mieux s'il était exécuté en tant que service, puis un thread Runnable généré à partir du service? Un service est-il considéré comme un thread distinct de l'interface utilisateur?

Comme vous pouvez le dire cette question est sur les bases du multithreading pour Android. Merci pour toute info.

public class Something extends Activity { 
    @Override 
    protected void onCreate(Bundle saved) { 
     super.onResume(); 
     final EGL10 egl = (EGL10) EGLContext.getEGL(); 
     final EGLDisplay eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY); 
     int[] version = new int[2]; 
     egl.eglInitialize(eglDisplay, version); 

     int[] configSpec = { 
      // EGL10.EGL_DEPTH_SIZE, 8, 
      EGL10.EGL_NONE 
     }; 

     final EGLConfig[] config = new EGLConfig[1]; 
     int num_configs[] = new int[1]; 
     egl.eglChooseConfig(eglDisplay, configSpec, config, 1, num_configs); 
     final EGLContext eglContext = egl.eglCreateContext(eglDisplay, config[0], EGL10.EGL_NO_CONTEXT, null); 

     // Setting up layouts and views 
     SurfaceView view = new SurfaceView(this); 
     setContentView(view); 

     SurfaceHolder holder = view.getHolder(); 
     holder.setType(SurfaceHolder.SURFACE_TYPE_GPU); 
     final GL10 gl = (GL10) eglContext.getGL(); 
     final Handler handler = new Handler(); 

     holder.addCallback(new Callback() { 
     private EGLSurface surface; 
     private Runnable painter; 

     @Override 
     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { 
      // initialize GL projection and other stuff 
      // gl.glMatrixMode(GL10.GL_PROJECTION); 
      // gl.glFrustumf(left, right, bottom, top, zNear, zFar); 
      // ... 
      painter = new Runnable() { 
      @Override 
      public void run() { 
       drawFrame(gl); 
       egl.eglSwapBuffers(eglDisplay, surface); 
       handler.post(this); 
      } 
      }; 
      handler.post(painter); 
     } 
     @Override 
     public void surfaceCreated(SurfaceHolder holder) { 
      surface = egl.eglCreateWindowSurface(eglDisplay, config[0], holder, null); 
      egl.eglMakeCurrent(eglDisplay, surface, surface, eglContext); 
     } 
     @Override 
     public void surfaceDestroyed(SurfaceHolder holder) { 
      handler.removeCallbacks(painter); 
     } 
     }); 
    } 

    private void drawFrame(GL10 gl) { 
     // Frame drawing... 
     long t = System.currentTimeMillis() % 10000; 
     gl.glClearColor(t/(float) 10000, t/(float) 10000 ,1 , 1); 
     gl.glClear(GL10.GL_COLOR_BUFFER_BIT); 
    } 
} 

Answer 1

En savoir plus sur AsyncTask dans un article de Google Android Team intitulé Painless threading

Comme avec mes propres mots, AsyncTask est un fil intelligent qui a deux méthodes qui fonctionnent sur thread d'interface utilisateur, de sorte que vous pouvez mettre à jour votre UI dans ces méthodes.