태그 보관물: AsyncTask

AsyncTask와 같이 사용하는 ProgressDialog를 사용해서 태스크를 바로 종료시키기

안드로이드 애플리케이션이 데이터를 로딩하는데 AsyncTask를 사용하고, 사용자에게 데이터 로딩을 알려주려고 ProgressDialog를 같이 사용하는 경우를 종종 볼 수 있다. 아래의 그림이 이 예제이다.

위 그림의 상황에서, 사용자가 다른 화면을 보길 원하거나 더는 로딩하기 원하지 않는 경우에도 ProgressDialog 클래스의 cancelable 변수를 false로 설정해서 백 키를 눌러도 데이터 로딩창을 종료하지 않고 계속 보이는 경우를 볼 수 있다. UX의 관점에서 보면, 이런 경우는 좋지 않다.

같은 상황에서 iOS 애플리케이션들의 UX를 보니, 많은 경우 화면을 전환하기 전에 데이터를 로딩하고 로딩을 완료하면 화면을 전환한다. 이 UX로 인해서 사용자는 로딩을 취소하고 쉽게 다른 화면으로 전환할 수 있다. 물론 꼭 그렇지는 않지만, 필자의 경우에는 비교적 iOS의 UX가 안드로이드보다 좋게 느껴진다. 그래서 안드로이드 애플리케이션도 ProgressDialog 창을 종료시키고, 데이터 로딩과 같은 비동기 요청(AsyncTask를 사용하는 경우)을 바로 취소하는 방법을 사용해서 비교적 UX를 개선할 수 있다. 사용자에게 조금 더 좋은 UX를 제공할 수 있는 이 방법을 살펴보자.

1. 백 키를 사용해서 종료하는 ProgressDialog 객체 생성

		pd = new ProgressDialog(this);
		pd.setTitle("");		
		pd.setMessage("Loading...");
		pd.setCancelable(true);
		pd.setOnDismissListener(new OnDismissListener() {
			@Override
			public void onDismiss(DialogInterface dialog) {
				Log.d(TAG, "onDismissed() ");
				
				task.cancel(true);
				//task.cancel(false);
			}
		});

이 코드는 ProgressDialog 객체를 생성하면서 백 키로 창을 종료하면서 Dismiss 이벤트를 받아서 비동기 데이터를 로딩하는 태스크인 task를 취소한다.

2. 비동기로 데이터를 로딩하는 AsyncTask 클래스

	static class LoadingTask extends AsyncTask<String, Integer, Boolean> {
		private ProgressDialog pd = null;
		
		public LoadingTask(ProgressDialog pd) {
			this.pd = pd;
		}
		
		@Override
		protected void onPreExecute() {	
			super.onPreExecute();
			if(pd != null)
				pd.show();
		}
		
		@Override
		protected Boolean doInBackground(String... params) {		
			try {
				Thread.sleep(1000 * 20);
			} catch(InterruptedException e) {
				Log.d(TAG, "Exception : " + e.getLocalizedMessage());
			}
			
			return Boolean.TRUE;
		}

		@Override
		protected void onCancelled(Boolean result) {
			Log.d(TAG, "onCancelled : " + result);
			
			if(pd != null)
				pd.dismiss();
		}
		
		@Override
		protected void onPostExecute(Boolean result) {
			Log.d(TAG, "onPostExecute : " + result);
			
			if(pd != null)
				pd.dismiss();
		}
	}

이 클래스는 비동기로 데이터를 로딩하는 형태로 비동기의 태스크 로직 메서드에서 20초를 Sleep하고 있다. 그리고 이 태스크의 취소에 대한 콜백 메서드인 onCancelled(Boolean result) 메서드를 확인할 수 있다.

이제 위에서 살펴본 코드를 사용해서 사용자가 백 키를 누른 경우, ProgressDialog를 종료하고 LoadingTask도 종료시킬 수 있다. AsyncTask를 종료하는 방법으로 cancel(boolean mayInterruptIfRunning) 메서드를 호출한다. 이 메서드를 호출하면 내부에서 cancelled 변수를 true로 설정한다. 그리고 mayInterruptIfRunning를 true로 호출하면 바로 종료시키기 위한 인터럽트를 던지게 된다. 그래서 AsyncTask가 IO를 looping하면서 읽어들이지 않는 경우에는 cancel(true)로 바로 종료시킬 수 있다.

다음으로 ProgressDialog가 종료하면서 AsyncTask를 취소하는 메서드의 호출 결과를 살펴보자.
– 아래는 cancel(false)을 호출한 결과이다.

01-30 05:56:05.720: D/MainActivity(1416): onDismissed() 
01-30 05:56:24.136: D/MainActivity(1416): onCancelled : true

이 결과로 cancel(false)을 호출하면, doInBackground()가 종료된 후에 onCancelled가 호출된 것을 알 수 있다.

– 아래는 cancel(true)을 호출한 결과이다.

01-30 05:58:33.038: D/MainActivity(1584): onDismissed()
01-30 05:58:33.038: D/MainActivity(1584): Exception : null
01-30 05:58:33.038: D/MainActivity(1584): onCancelled : true

cancel(true)을 호출 결과로 AsyncTask의 doInBackground() 메서드에서 InterruptedException이 발생하게 되고, 이것으로 바로 태스크 로직을 빠져나오게 한다.

이상 살펴본 형태로 AsyncTask와 ProgressDialog를 결합해서 사용하는 경우에 사용자의 반응에 즉시 반응할 수 있는 형태로 개발해서 UX를 개선할 수 있다.

Android 4.4 AsyncTask 개선점..

안드로이드에서 제일 많이 사용하는 쓰레드 형태가 AsyncTask를 상속하는 구조이고, AsyncTask의 개선은 바로 전체적인 성능개선으로 이어질 가능성이 높다.

AsyncTask의 최신(4.4 KitKat) 버전과 이전(4.3 Jelly Bean)을 비교해 보자.

위 그림에서 최신버전의 180, 181줄의 코드를 확인해 보면, 디바이스의 CPU의 개수에 따른 최적화가 눈에 띈다.

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;

하지만, 기존의 코드에서는 아래의 코드로 하드코드되어 있어서 CPU가 2개인 디바이스에서는 오히려 성능을 저하시킬 수도 있다.

private static final int CORE_POOL_SIZE = 5;

위의 코드가 간단해 보일지 모르겠지만, 자바에서 Concurrent 쓰레드 프로그래밍에서는 매우 중요한 포인트이다. 이 작은 포인트가 디바이스에 최적화된 코드중의 일부라고 보면 되겠다.

LIFO 구조의 AsyncTask 디스패칭 구현하기..

안드로이드에서 우측의 GridView의 썸네일들을 API 서버에서 받아온다고 가정을 합니다. API 서버를 통해서 각 썸네일을 가져오려면, 보통은 Adapter의 getView()메쏘드에서 썸네일을 가져오는 AsyncTask를 순서대로 실행을 할 것입니다. 순서대로 FIFO의 구조로.. 그렇지만, 터치를 해서 두번 정도만 아래로 내려도, FIFO 구조가 좋지 않은 것은 자명한 일리겠죠.. 화면에 보이지도 않는 썸네일을 가져오는 쓰레드가 Background로 돌고 있겠죠.. 그래서, LIFO 구조로 AsyncTask를 디스패칭하는 넘을 만들어 봤습니다.. 

많은 썸네일을 보여주기 위해서는, 보통 페이징을 합니다. 썸네일을 보려고, 빠르게 터치해서 이동하다 보면, 쓰레드가 많이 생기게 마련이고, 이런경우에 쓰레드 응답문제로 앱이 죽을 수 있습니다.. 물론, THREAD_POOLING을 이용하는 EXECUTOR를 사용한다고 해도, AsyncTask의 과도한 큐잉으로 인해서 죽을 수도 있습니다.. 

그래서, AsyncTask를 중간에 큐잉(화면에 나오지 않을 넘들까지 큐잉할 필요는 없다고 생각함)을 하고, AsyncTask를 디스패칭(엄밀히 말하면, Executor에 넘겨주는..)을 담당하는 매니저를 두는 것으로 간단하게 해결을 합니다. 디스패칭을 담당하는 클래스는 기본적으로 DEQUE를 사용해서 LIFO구조의 QUEUE를 사용합니다.. 

참고로, 구현된 코드의 일부만 발췌를 했기 때문에, 아래의 코드는 컴파일이 안됩니다.. 필요한 부분은 적당한 수정과 추가가 필요합니다..

1. AsyncTaskVO.java

public class AsyncTaskVO {

public Context c;

public AsyncTask<String, Integer, Bitmap> task;

public static AsyncTaskVO newInstance(Context c, AsyncTask<String, Integer, Bitmap> task) {

AsyncTaskVO vo = new AsyncTaskVO();

vo.c = c;

vo.task = task;

return vo;

}

}

2. AsyncTaskDispatcher.java

import java.util.ArrayList;

import java.util.concurrent.LinkedBlockingDeque;

import java.util.concurrent.atomic.AtomicInteger;

public class AsyncTaskDispatcher {

static String CNAME = AsyncTaskDispatcher.class.getSimpleName();

public static AtomicInteger runningTask = new AtomicInteger(0);

static int MAX_SIZE = 72;

static int HALF_MAX_SIZE = 36;

static LinkedBlockingDeque<AsyncTaskVO> queue = new LinkedBlockingDeque<AsyncTaskVO>(MAX_SIZE); 

static ArrayList<Thread> consumers = new ArrayList<Thread>(3);

static {

consumers.add(new Thread(new Consumer(“1”)));

consumers.add(new Thread(new Consumer(“2”)));

consumers.add(new Thread(new Consumer(“3”)));

consumers.get(0).start();

consumers.get(1).start();

consumers.get(2).start();

}

public static void put(AsyncTaskVO e) {

if(e == null)

return;

try {

queue.addFirst(e);

if(queue.size() > HALF_MAX_SIZE) {

AsyncTaskVO taskVo =queue.takeLast();

if(DEBUG)

Logger.w(CNAME, “task deleted ~~” + taskVo);

taskVo = null;

return;

}

if(DEBUG)

Logger.w(CNAME, “task added~~”);

} catch (InterruptedException e1) {

if(DEBUG)

Logger.e(CNAME, ExceptionUtil.getException(e1));

}

}

public static class Consumer implements Runnable {

private String name = “”;

final Object lock = new Object();

public Consumer(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public void run() {

while(true) {

synchronized (lock) {

try {

// 실행중인 Task가 20개가 넘으면 wait을 한다. 

if(runningTask.intValue() > 20)

lock.wait(200);

if(DEBUG)

Logger.e(CNAME, “running task size = ” + runningTask.intValue());

AsyncTaskVO taskVo = queue.takeFirst();

if(taskVo == null || taskVo.c == null || taskVo.task == null) {

if(DEBUG)

Logger.e(CNAME, “TASK : NULL”);

return;

}

if(!NetworkUtil.isAvailable(taskVo.c)) {

queue.clear();

return;

}

taskVo.task.executeOnExecutor(EXECUTOR, “”);

} catch(Exception e) {

if(DEBUG)

Logger.e(CNAME, ExceptionUtil.getException(e));

}

}

}

}

}

3. GetThumbnailTask.java

public class GetThumbnailTask extends AsyncTask<String, Integer, Bitmap> {

static final String CNAME = GetThumbnailTask.class.getSimpleName();

@Override

public void onPreExecute() {

AsyncTaskDispatcher.runningTask.incrementAndGet();

}

@Override

protected Bitmap doInBackground(String… params) {

// 여기에서 Bitmap 이미지를 가져온다. 

}

@Override

protected void onPostExecute(Bitmap result) {

AsyncTaskDispatcher.runningTask.decrementAndGet();

}

}

LIFO 구조의 AsyncTask 디스패칭을 실행하는 방법은, 위의 GetThumbnailTask를 Adapter에서 생성해서 AsyncTaskDispatcher에 추가만 하면 됩니다. 

Android java.util.concurrent.RejectedExecutionException 핸들링(2/2)..

앞에서 Android java.util.concurrent.RejectedExecutionException 핸들링(1/2).. 하기라는 포스팅에서 안드로이드에서 상당히 많은 쓰레드를 단기간에 실행(보통 안드로이드 개발가이드만 보면 유발 가능)시키면 RejectedExecutionException이 발생하고 이것에 대한 간단한 해결책을 기술했습니다. 그 내용과 더불어서 위 상황을 해결할 수 있는 방법으로, 좀 더 편리한 방법을 기술해 봅니다.

이 방법은 위 링크에서 설명하고 있는 ExecutorService가 실행하는 방식과 비슷한 Producer Consumer 패턴을 이용해서 해결할 수 있습니다. Producer는 간단하게 AsyncTask를 실행할 데이터를 Queue에 입력하는 코드가 되겠고, Consumer는 Queue에 들어간 데이터를 가져와서 AsyncTask를 실행하는 쓰레드입니다..

아래 코드는 실시간으로 바로 응답이 필요한 Task보다는, 한꺼번에 많은 Task를 Queue에 담았다가 약간 지연(위의 Exception 상황 회피)를 주면서 처리하는 코드에 유용하게 사용할 수 있습니다.

아래 PhotoDispatcher 클래스는, 위의 설명대로 Queue와 Consumer를 유지하면서, Queue에 처리할 데이터가 들어오면 Consumer가 Queue에서 데이터를 가져와서 AsyncTask를 실행시킵니다. ^^

public class PhotoDispatcher {
    static String CNAME = PhotoDispatcher.class.getSimpleName();
    static BlockingQueue<Element> queue = new ArrayBlockingQueue<Element>(500);
    static ArrayList<Thread> consumers = new ArrayList<Thread>(2); // 쓰레드 2개
   
    static {
        consumers.add(new Thread(new Consumer(“1”)));
        consumers.add(new Thread(new Consumer(“2”)));
       
        consumers.get(0).start();
        consumers.get(1).start();
    }
       
    public static void put(PhotoElement e) {
        if(e == null)
            return;
       
        try {
            queue.put(e);
        } catch (InterruptedException e1) {
            LogUtil.e(CNAME, LogUtil.TAG, ExceptionUtil.getException(e1));
        }
    } 
   
    public static class Consumer implements Runnable {
        private String name = “”;
        public Consumer(String name) {
            this.name = name;
        }
       
        @Override
        public void run() {
            while(true) {
                try {
                    Element element = queue.take();
                   
                    if(IS_DEBUG) {
                        LogUtil.w(CNAME, LogUtil.TAG, “NAME : ” + name);
                        LogUtil.w(CNAME, LogUtil.TAG, “ELEMENT : ” + element.toString());
                        LogUtil.w(CNAME, LogUtil.TAG, “URL : ” + AuthService.thumbnailServerUrl);
                    }
                   
                    if(element != null) {
                        // 썸네일 가져오는 Task
                        new GetThumbnailTask(element.c, element.iv, element.fileId).execute(element.fileId);
                    }
                   
                    // 쓰레드를 0.5초 딜레이 시킨다.
                    Thread.sleep(500);
                } catch(Exception e) {
                    LogUtil.e(CNAME, LogUtil.TAG, ExceptionUtil.getException(e));
                }
            }
        }
    }
}

   

Android java.util.concurrent.RejectedExecutionExecution 핸들링(1/2)..

안드로이드 API의 AsyncTask는 API Level 3부터 지원하는 클래스로, UI 스레드가 아닌 스레드(백그라운드 스레드)를 생성하고 실행한 결과를 UI 스레드에 전달(Looper라는 놈이 전달함)하는 래퍼이다. AsyncTask를 사용하는 방법은 이 클래스를 상속해서 doInBackground() 메서드를 구현하면 된다. 아래 내용은 안드로이드 2.2 기반에서의 경험한 내용이다.

그래고, 많은 데이터를 가지고 오기 위해서 페이징을 합니다. 안드로이드는 하단에 spinner와 Loading과 같은 메세지가 표준처럼 사용되고 있죠.

사진에 대한 Thumbnail이 매우 많고, 30개씩 가져온다고 가정을 합니다.. 보통 ArrayAdapter나 ListAdapter를 상속받아서 Adapter 객체를 만들고, Adapter 객체의 getView()에서 랜더링을 위한 작업을 구현하게 됩니다.

@Override
public View getView(int position, View cView, ViewGroup parent) {
}

Thumbnail을 가져와야 하니, 보통 위 메소드 안에서 Thumbnail을 가져오기 위해, AsyncTask를 상속받은 쓰레드로 처리를 하는 것이 일반적입니다. 이 상황은 쓰레드를 많이 생성하게 됩니다..

위의 경우에 RejectedExecutionException 이 발생할 수 있습니다.. 안드로이드는 내부적으로 java.util.concurrent 패키지의 ExecutorService를 Thread 디스패칭에 사용하고 있습니다. 따라서, 요 문제는 아래의 ExecutorService가 처리해야 하는 AsyncTask의 POOL_SIZE가 순간적으로 넘어서고, 이 경우에 AsyncTask가 풀에 들어갈 수 없어서 발생하는 익셉션입니다. 위 문제는 빈번하게 발생하지 않을 것 같지만, 게임이라던지 쓰레드가 많이 필요한 작업을 하다 보면 발생할 수 있습니다..

아래는 Android 플랫폼에서 기본적으로 가지고 있는 AsyncTask의 정책값입니다.

private static final int CORE_POOL_SIZE = 1;
private static final int MAXIMUM_POOL_SIZE = 10;
private static final int KEEP_ALIVE = 10;

따라서, 위 문제는 하나의 쓰레드로 30개의 이미지를 가져오는 형태로 살짝 바꾸면 해결이 됩니다. 당근 성능과 안전성의 트레이드 오프라고 할 수 있겠습니다..

위에서 간단하게 RejectedExecutionException을 피해갈 수 있는 방안에 대해서 살펴보았습니다..
위에서 고려한 사진의 Thumbnail에 대한 예로, 한번 더 고민을 해 보면, 만약에 30개를 가져오는 쓰레드를 getView()외에서 처리를 한다면, 지금 보고 있는 화면에서 사진이 안 보일 겁니다.. 왜냐하면, getView()에서 처리를 하지 않았기 때문에 빈 사진만 보이겠죠.

그래서, 위 가정대로, 사진이 많아서 페이징을 해야하고 Thumbnail을 보여준다면, 사진을 가져오는 첫 페이지에서는 getView()에서 AsyncTask를 불러서 사진을 가져오고, 두 번째 페이지 부터는 데이터를 가져와서 Adapter에 바인딩하는 쓰레드가 30개의 사진을 처리하는 쓰레드를 다시 부르는 형태로 구현을 하는 것이 좋을 것 같습니다..