24.11.18
Callable 인터페이스 (in java.util.concurrent)
: 스레드에서 실행할 작업을 정의
: Callable<T>에서 T는 call() 메서드의 반환 타입
: 기본적으로는 ExecutorService를 쓴다고 하지만 내가 보던 코드에서는 A11이후로 deprecated된 AsyncTask를 활용하길래 찾아봤더니 정리를 잘 해둔 곳이 있었다.(참고: https://javacan.tistory.com/entry/maintainable-async-processing-code-based-on-AsyncTask) 그리고 이걸 ExecutorService로 변경해봤다.(도움: chatGPT)
// * AsyncTask 사용하던 코드
private AsyncExecutor.AsyncCallback<TestWrapper> getTestCommand
= new AsyncExecutor.AsyncCallback<TestWrapper>() {
@Override
public void onResult(TestWrapper result) {
if (result != null) {
// 비동기 처리 완료 시 진행할 내용
}
@Override
public void exceptionOccured(Exception e) {
// 예외가 발생했을 시 진행할 내용
}
@Override
public void cancelled() {
// 비동기 작업 취소 시 진행할 내용
}
};
private void testCommand(final int c) {
Callable<TestWrapper> callable = () -> {
TestWrapper wrap = new TestWrapper();
// 비동기로 작업할 내용 추가
return wrap;
};
new AsyncExecutor<TestWrapper>().setCallable(callable)
.setCallback(getTestCommand).execute();
}
===============================================================================================
import android.os.AsyncTask;
import android.util.Log;
import java.util.concurrent.Callable;
public class AsyncExecutor<T> extends AsyncTask<Void, Void, T> {
private static final String TAG = "AsyncExecutor";
private AsyncCallback<T> callback;
private Callable<T> callable;
private Exception occuredException;
public AsyncExecutor<T> setCallable(Callable<T> callable) {
this.callable = callable;
return this;
}
public AsyncExecutor<T> setCallback(AsyncCallback<T> callback) {
this.callback = callback;
return this;
}
@Override
protected T doInBackground(Void... params) {
try {
return callable.call();
} catch (Exception ex) {
Log.e(TAG, "exception occured while doing in background: " + ex.getMessage(), ex);
this.occuredException = ex;
return null;
}
}
@Override
protected void onPostExecute(T result) {
if (isCancelled()) {
notifyCanceled();
}
if (isExceptionOccured()) {
notifyException();
return;
}
notifyResult(result);
}
private void notifyCanceled() {
if (callback != null)
callback.cancelled();
}
private boolean isExceptionOccured() {
return occuredException != null;
}
private void notifyException() {
if (callback != null)
callback.exceptionOccured(occuredException);
}
private void notifyResult(T result) {
if (callback != null)
callback.onResult(result);
}
public interface AsyncCallback<T> {
public void onResult(T result);
public void exceptionOccured(Exception e);
public void cancelled();
}
}// * ExectorService를 사용하는 코드
private AsyncExecutor.AsyncCallback<TestWrapper> getTestCommand
= new AsyncExecutor.AsyncCallback<TestWrapper>() {
@Override
public void onResult(TestWrapper result) {
if (result != null) {
// 비동기 처리 완료 시 진행할 내용
}
@Override
public void exceptionOccured(Exception e) {
// 예외가 발생했을 시 진행할 내용
}
@Override
public void cancelled() {
// 비동기 작업 취소 시 진행할 내용
}
};
private void testCommand(final int c) {
Callable<TestWrapper> callable = () -> {
TestWrapper wrap = new TestWrapper();
// 비동기로 작업할 내용 추가
return wrap;
};
new AsyncExecutor<TestWrapper>().setCallable(callable)
.setCallback(getTestCommand).execute();
}
===============================================================================================
import java.util.concurrent.*;
public class AsyncExecutor<T> {
private static final String TAG = "AsyncExecutor";
private AsyncCallback<T> callback;
private Callable<T> callable;
private Exception occuredException;
public AsyncExecutor<T> setCallable(Callable<T> callable) {
this.callable = callable;
return this;
}
public AsyncExecutor<T> setCallback(AsyncCallback<T> callback) {
this.callback = callback;
return this;
}
public void execute() {
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<T> future = executorService.submit(callable);
new Thread(() -> {
try {
T result = future.get();
if (Thread.currentThread().isInterrupted()) {
notifyCanceled();
} else {
notifyResult(result);
}
} catch (InterruptedException e) {
notifyCanceled();
} catch (ExecutionException e) {
occuredException = e.getCause();
notifyException();
} finally {
executorService.shutdown();
}
}).start();
}
private void notifyCanceled() {
if (callback != null) {
callback.cancelled();
}
}
private boolean isExceptionOccured() {
return occuredException != null;
}
private void notifyException() {
if (callback != null) {
callback.exceptionOccured(occuredException);
}
}
private void notifyResult(T result) {
if (callback != null) {
callback.onResult(result);
}
}
public interface AsyncCallback<T> {
void onResult(T result);
void exceptionOccured(Exception e);
void cancelled();
}
}
- Runnable과의 차이점
1) Callable의 call()은 작업을 실행하고 결과를 반환하지만 Runnable의 run()은 결과 반환하지 않음
2) Callable은 예외를 던질 수 있지만 Runnable은 예외를 던지지 않음
Executor 인터페이스
: 매개변수로 들어온 Runnable 객체를 실행하는 객체
: 명시적인 스레드 생성 대신 사용됨
: 보통은 이 인터페이스 자체를 쓰기보다는 확장된 인터페이스들을 사용
ExecutorService 인터페이스
: Task만 지정해주면 알아서 스레드풀을 이용해 Task를 실행하고 관리해줌
: Task는 Queue로 관리됨
: Task를 submit하면 개발자가 생명주기 관리할 필요없이 내부에서 해당 Task를 스케줄링하면서 적절하게 일을 처리
- 객체 생성 방법
1) 구현체인 ThreadPoolExecutor로 초기화
: new ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>)
: new ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, RejectedExecutionHandler)
: new ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, ThreadFactory, RejectedExecutionHandler)
2) Executors 클래스에서 제공하는 정적 팩토리 메소드로 초기화
: Executors.newCachedThreadPool()
: Executors.newFixedThreadPool(int)
: Executors.newSingleThreadExecutor()
- CachedThreadPool
1) 일정시간동안 스레드를 검사하여 60초동안 Task가 없으면 스레드풀에서 제거
2) 스레드 제한 없이 무제한 생성 가능
- FixedThreadPool
1) 고정된 스레드 개수를 가지는 스레드풀
2) CPU 코어수 기준으로 생성 시 효율 상승
- SingleThreadExecutor
1) 스레드가 한 개인 스레드풀
- Task 할당을 위해 제공되는 메소드들
1) execute()
: 반환 타입이 void
: Task의 실행 결과나 상태 인지 불가
2) submit()
: 반환 타입이 Future<T>
: Callable을 구현한 Task를 넘겨 결과를 반환받음
3) invokeAny()
: 반환 타입이 Future<T>
: Task를 리스트에 넣어서 전달하고 성공한 Task 중 하나의 결과값을 반환
4) invokeAll()
: 반환 타입이 List<Future<T>>
: Task를 리스트에 넣어서 전달하고 모든 Task의 결과값을 반환
- ExecutorService 종료를 위해 제공되는 메소드들
1) shutdown()
: 실행 중인 모든 Task가 수행되고나서 종료
2) shutdownNow()
: 실행 중인 모든 Task를 종료시키려고 하지만 보장하지는 않고 실행되지 않은 Task를 반환
3) awaitTermination()
: 새로운 Task 할당을 막고 일정 시간동안 실행 중인 Task를 기다리다가 시간이 지나면 강제 종료
ProgressDialog
: A8(API Level 26)부터 deprecated됨
- 간단한 대체 코드
Dialog dialog = new Dialog(this);
dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
dialog.setContentView(new ProgressBar(this));
dialog.setCanceledOnTouchOutside(false);
dialog.setOnCancelListener(dialogInterface -> finish());
dialog.show();
비트마스크를 통한 문자의 바이트 길이 계산
// UTF-8 인코딩된 데이터의 바이트 배열
byte[] data = text.getBytes();
int i = 0;
while(I < data.length) {
byte CharLen;
// 8비트 중에서 가장 왼쪽 비트가 0이라면 1바이트 문자
if ((data[i] & -128) != -128) {
CharLen = 1;
// 8비트 중에서 6번째 비트가 0이라면 2바이트 문자
} else if ((data[i] & 32) != 32) {
CharLen = 2;
// 8비트 중에서 5번째 비트가 0이라면 3바이트 문자
} else if ((data[i] & 16) != 16) {
CharLen = 3;
// 8비트 중에서 4번째 비트가 0이라면 4바이트 문자
} else if ((data[i] & 8) != 8) {
CharLen = 4;
// 8비트 중에서 3번째 비트가 0이라면 5바이트 문자
} else if ((data[i] & 4) != 4) {
CharLen = 5;
// 위의 조건에 해당되지 않는다면 6바이트 문자
} else {
CharLen = 6;
}
}
UTF-8 인코딩은 가변 길이 인코딩을 사용하며, 하나의 문자가 1바이트에서 6바이트까지 사용가능
1바이트 문자 : 0xxxxxxx
2바이트 문자 : 110xxxxx 10xxxxxx
3바이트 문자 : 1110xxxx 10xxxxxx 10xxxxxx
4바이트 문자 : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
5바이트 문자 : 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
6바이트 문자 : 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxxx
바이트 변수의 하위 8비트만 추출하는 방법
data & 0xff
바이트 변수의 값을 이용해서 2바이트(16비트) 정수를 만드는 방법
((byte) b[4] & 0xff) + ((byte) b[3] & 0xff) * 256;
((byte) b[4] & 0xff) : 하위 8비트
((byte) b[3] & 0xff) * 256 : 상위 8비트(2의 9승을 곱했기 때문에)
간단한 지연 함수
public static void delay(long time) {
if (time > 0) {
try {
Thread.sleep(time);
} catch (InterruptionException e) {
Log.d(TAG, e.message());
}
}
}