Kyle's Life Lab

호출하는 측과 호출받는 측의 개념으로 이해하세요

보통 call이라함은 사용자 프로세스가 어떤 시스템(주로 운영체제겠지요?)에게 임의의 서비스를 호출하는 것을 의미합니다. 즉, 처리루틴은 시스템에 있고, 사용자 프로세스는 그것을 호출한다는 의미지요.

callback : call에서는 사용자==>시스템 이었는데 이제는 거꾸로 호출해주는 것입니다. 시스템이 사용자의 루틴을 호출해주는것이지요. 호출의 시점이 시스템에서 사용자로 가는것에 유의해주시길. 즉, 사용자 프로그램루틴을 사용자가 호출하는것이 아니라, 이벤트처리루틴등에 의해 시스템이 사용자 프로그램을 호출해 주는 것을 의미합니다.

upcall : call은 보통 상위에서 하위(기반)시스템에게 호출이 일어나는데, 마이크로커널같은 구조에서는 커널에 서비스 루틴이 있지 않고, 사용자 레벨에 이런 서비스루틴이 존재하는 경우가 있습니다. 심지어 메모리 관리자도 사용자 수준에 있지요. 따라서, 다음과 같은 시나리오를 그려볼 수 있습니다.

사용자 =(call)==> 시스템 =(upcall)=>라이브러리커널=(return)=>시스템=(return)=>사용자

전 포스트에서 설명했던 여러 스레드 구현방법들은 비록 아무 문제가 없지만 구현방법이 복잡해서 코드를 읽기 힘들게 만드는 경향이 있었다. Background작업에 관한 모든 사항(스레드 객체 생성, 사용, UI스레드와 통신 등)이 Activity 코드에 포함 되고 특히 background 스레드가 UI위젯과 빈번한 통신을 할수록 Activity 코드의 복잡함은 점점 배가 된다. 

안드로이드에서는 이런 문제를 해결하기 위해 API level 3 (1.5 version) 부터 AsyncTask라는 클래스를 제공하고 있다. 

AsyncTask클래스는 background작업을 위한 모든 일(스레드생성, 작업실행, UI와 통신 등)을 추상화 함으로 각각의 background작업을 객체 단위로 구현/관리 할 수 있게 하는것이 목적이다. 그림으로 표현하면 다음과 같다.

참고로 1.0과 1.1 version의 API를 사용하는 디바이스에서는 구글 code에 공개되어 있는 UserTask 라는 클래스를 어플리케이션 프로젝트에 복사해 넣어 사용할 수 있다. 기능과 사용법은 AsyncTask와 완전히 동일하다.

그럼 AsyncTask에 관해 자세히 살펴보자.

1. AsyncTask 클래스 소개

AsyncTask라는 클래스 이름은 Asynchronous Task의 줄임이며, UI스레드의 입장에서 볼 때 비동기적으로 작업이 수행되기 때문에 붙여진 이름이다. (Ajax: Asynchronous javascript and XML 에서 사용된 의미와 같다)

AsyncTask의 상속관계는 다음과 같다.

Object로부터 상속하는 AsyncTask는 Generic Class이기 때문에 사용하고자 하는 type을 지정해야 한다.

AsyncTask클래스의 사용시 지정해야 하는 generic type은 각각 다음의 용도로 사용된다.

• Params: background작업 시 필요한 data의 type 지정
• Progress: background 작업 중 진행상황을 표현하는데 사용되는 data를 위한 type 지정
• Result: background 작업 완료 후 리턴 할 data 의 type 지정

그림으로 각 generic type이 결정하는 것들을 표현하면 다음과 같다.

(각 메소드의 자세한 정보는 다음 단락의 예제 코드와 설명 참조)

만약 type을 정할 필요가 없는 generic이 있다면 void를 전달하면 된다.

예. …AsyncTask<void, void, void> {…}

2. AsyncTask의 사용

우선 AsyncTask가 어떻게 사용되는지 예제 소스를 보자.

AsyncTask 클래스의 사용 예

접기

접기

AsyncTask 클래스는 다음과 같이 중요한 callback들을 제공 함으로 상황에 맞게 오버라이딩 해야 한다.

• protected void onPreExecute(): Background 작업이 시작되자마자 UI스레드에서 실행될 코드를 구현해야 함. (예. background 작업의 시작을 알리는 text표현, background 작업을 위한 ProgressBar popup등)
• protected abstract Result doInBackground(Params… params): Background에서 수행할 작업을 구현해야 함. execute(…) 메소드에 입력된 인자들을 전달 받음.
• void onProgressUpdate(Progress... values): publishProgress(…) 메소드 호출의 callback으로 UI스레드에서 보여지는 background 작업 진행 상황을 update하도록 구현함. (예. ProgressBar 증가 등)
• void onPostExecute(Result result): doInBackground(…)가 리턴하는 값을 바탕으로 UI스레드에 background 작업 결과를 표현하도록 구현 함. (예. background작업을 계산한 복잡한 산술식에 대한 답을 UI 위젯에 표현함 등)
• void onCancelled(): AsyncTask:cancel(Boolean) 메소드를 사용해 AsyncTask인스턴스의 background작업을 정지 또는 실행금지 시켰을 때 실행되는 callback. background작업의 실행정지에 따른 리소스복구/정리 등이 구현될 수 있다.

또, AsyncTask 클래스는 background 작업의 시작과 background 작업 중 진행정보의 UI스레드 표현을 위해 다음과 같은 메소드를 제공한다.

• final AsyncTask<…> execute(Params… params): Background 작업을 시작한다. 꼭 UI스레드에서 호출하여야 함. 가변인자를 받아들임으로 임의의 개수의 인자를 전달할 수 있으며, 인자들은 doInBackground(…) 메소드로 전달된다.
• final void publishProgress(Progress... values): Background 작업 수행 중 작업의 진행도를 UI 스레드에 전달 함. doInBackground(…)메소드 내부에서만 호출.

위의 메소드들은 AsyncTask 클래스를 이용해 구현된 background 작업 시 다음과 같은 형태로 사용된다.

위 의 그림에서 처럼AsyncTask인스턴스는 자기 자신을 pending, running, finished 이렇게 세 가지 상태(status)로 구분하는데 각각 AsyncTask:Status 클래스에 상수 PENDING, RUNNING, FINISHED로 표현 될 수 있다.

현재 AsyncTask인스턴스의 상태는 다음 메소드를 호출해서 얻을 수 있다.

return

AsyncTask인스턴스의 상태정보를 AsyncTask.Status 객체의 상수 값 PENDING, RUNNING, FINISHED 중에서 리턴.

또, AsyncTask클래스는 background 작업을 정지, 또는 시작금지 시키기 위해 다음 메소드를 제공한다. 이 메소드가 성공적으로 호출되면 onCacelled() callback이 호출되니 onCacelled()에 적절한 뒤처리를 해주어야 한다.

parameter

mayInterruptIfRunning: true값을 제공했을 때 background작업이 실행 중일 경우(running 상태) 작업을 중단 시키고, 준비 중(pending 상태) 일 경우 작업을 실행 금지 시킴. (execute() 명령 사용 불가. 사용하면 exception 발생)

return

true: background작업을 성공적으로 중지하거나 실행 금지 시킴

false: 벌써 작업이 완료된 상태(finished 상태) 일 경우 리턴

마지막으로 AsyncTask 사용해 background작업을 구현 시 꼭 지켜야 하는 사항들이다.

• AsyncTask클래스는 항상 subclassing 하여 사용하여야 한다.
• AsyncTask 인스턴스는 항상 UI 스레드에서 생성한다.
• AsyncTask:execute(…) 메소드는 항상 UI 스레드에서 호출한다.
• AsyncTask:execute(…) 메소드는 생성된 AsyncTask 인스턴스 별로 꼭 한번만 사용 가능하다. 같은 인스턴스가 또 execute(…)를 실행하면 exception이 발생하며, 이는 AsyncTask:cancel(…) 메소드에 의해 작업완료 되기 전 취소된 AsyncTask 인스턴스라도 마찬가지이다. 그럼으로 background 작업이 필요할 때마다 new 연산자를 이용해 해당 작업에 대한 AsyncTask 인스턴스를 새로 생성해야 한다.
• AsyncTask의 callback 함수 onPreExecute(), doInBackground(…), onProgressUpdate(…), onPostExecute(…)는 직접 호출 하면 안 된다. (꼭 callback으로만 사용)

안드로이드는 스윙과 마찬가지로 싱글 쓰레드 GUI 모델이 적용되어 있다. 
즉 UI를 그리거나 갱신하는 쓰레드는 하나뿐이라는 것이다. 그 쓰레드는 바로 안드로이드의 주요 컴포넌트들이 실행되는 "main" 쓰레드이다. 모든 UI 관련 코드는 main 쓰레드에서 실행된다.

스윙에서 응답없음(unresponsive) 현상을 막기 위해 백그라운드에서 돌아가는 worker 쓰레드를 만든 것처럼, 안드로이드에서도 오래 걸리는 작업은 UI 쓰레드(= main 쓰레드)에서 처리하지 말고 별도의 쓰레드를 만들어 처리해야 한다. 그렇지 않으면 화면을 갱신하고자 하는 모든 코드는 block 당하여 ANR이 발생할 것이다.

오래 걸리는 작업에는 무엇이 있나?
- 파일 처리
- 네트워크 조회
- 다량의 DB 트랜잭션
- 복잡한 계산

그럼 백그라운드 쓰레드(Worker Thread)를 만드는 방법은?
- UI 쓰레드와 상호작용 없으면 그냥 Thread.start()에서 처리하면 된다.
- 그러나 작업후 결과를 UI에 반영(즉 UI 쓰레드와 통신)해야 한다면 Handler 등을 이용해야 한다.

다른 쓰레드에서 UI 쓰레드에 액세스하는 방법

Handler는 무엇인가?
- 쓰레드간 상호작용을 위한 일반적인 목적의 클래스
- 작업 쓰레드(=자식 쓰레드)에서 부모 쓰레드(=Handler 객체를 생성한 쓰레드)에 Message 및 
  Runnable(부모 쓰레드에서 처리할 작업) 전달(send/post 메소드)
- 자식 쓰레드에서 handler를 통해 전달되는 Message와 Runnable은 부모 쓰레드의 메시지큐에 들어감
- 내부적으로 Runnable도 결국은 Message로 변환(Message.callback=runnable)되어 메시지큐에 들어감
- Handler 객체를 생성한 쓰레드(부모 쓰레드)에서는 Looper를 통해 MessageQueue를 만들어 놓아야 함
- UI쓰레드(= main쓰레드)는 ActivityThread.main()에 의해 생성되는데, 여기서 Looper를 통해 
  UI 쓰레드용 메시지 큐가 이미 만들어져 있으므로 우리가 UI 쓰레드용 메시지큐를 만들 필요는 없음
- HandlerThread 클래스는 Looper를 가진 쓰레드를 쉽게 만들기 위한 용도

* 안드로이드 쓰레드에 대한 'i티거'님의 글 참조

http://tigerwoods.tistory.com/26 Thread 구현하기1

이서비스는 쓰레드로 만들었습니다.
그리고 윈도우는 메인함수에서 메인쓰레드라는게 존재한다.
그리고 각각 동작한다.

그리고 아까이야기 했듯이 클래스단위로 쓰레드화 하는게 아니고
하나의 컨숨?한 쓰레드가 됩니다.
이 프로듀서를 어디서 생성을 할까요->메인에서 생성할겁니다.
끄려면 강제종료를 시켜야하는데 그러면 메인이 종료됩니다.
그러면서 자식쓰레드들도 종료가됩니다.

그럼 소멸자가 어디서 불릴까? ->메인스레드
서비스함수들은 어디서 돌아가고 있을까? -> 각각 자기스레드

그럼 소멸자가 호출되는 순간 그 스레드들은 돌고있을까 안돌고있을까?
-> 돌고있고 소멸자가 호출되도 돌리려고 시도 할 수 있다. -> 그러면 터진다

해결책
플래그변수를 불러요 -> Customer에 boolean변수 isEnd를 만든다
volatile -> 최적화 안하겠다 -> 캐싱하지 않겠다 ->멀티코어에서 발생할수있는 버그를 없애겠다
-> 메모리에 있는 변수 캐쉬에 올리지마. 느려도 걍 쓸테니
->컴파일러의 코드순서바꾸기도 방지

캐시 아이오 속도차이 를 극복하기위해 각각 자신이 사용하는 변수를 캐싱한다. 메모리의 복사본을
캐시메모리에 올린다. 하나의 메모리를 두개의 시피유에서 사용한다.

그리고 isEnd를 false로 세팅하고 각각의 소멸자에 true로 바꿔준다.
서비스는 isEnd가 Ture일때까지 돌도록 바꾼다

isend가 한번더 돌다가 종료할때

->>>>>>>>>> 하지만 그래도 터진다.

서로 스레드가 다르므로 생산자로 넘어갔을때 한번 실행하고 돌아간다.
이 미묘한 타이밍때문에 똑같이 터진다.

>>>>>>>>>>>>>>>>>> while루프를 빠져나와서 온순간까지 락걸어준다.

소멸자에서 wait코드가 있는거고 while루프 바깥에서 풀어주고
생성자는 리소스에 대해서 락걸고 while루프 바깥에서 풀어버리면 세이프한 코드가 된다.

. 저번주에 한 생산자/소비자 실습에서 프로그램 종료시에 에러가 날 수 있는 조건과 해결책에 대한 필기 문제
메인함수에서 프로듀서와 커스토머 쓰레드를 만들고
메인쓰레드가 종료될때 아직 이 두개의 쓰레드는 각자 자기 쓰레드에서 돌고 있는데, 메인쓰레드를 종료되면 터진다.
왜냐하면 메인쓰레드가 종료될때 소멸자가 호출되는데 이 호출되는 순간에도 각자 자신의 쓰레드가 돌고 있기 때문이다. 그러므로 메인쓰레드가 종료될때 소멸자가 호출되는것을 이용하여 소멸자가 호출되었을대
모든 자식 스레드를 종료해주기 위해 자신의 스레드가 종료되도록하게 한다. 그리고 그다음 메인스레드가 종료되게하면 문제가 해결된다.
::CloseHandle( ( HANDLE )( _threadHandle ) );

메인스레드가 종료될때 소멸자가 호출되는데
Thread::~Thread()
{
 ::WaitForSingleObject( ( HANDLE )( _threadHandle ), INFINITE); //반드시해주어야함 모든 자식 스레드를 종료해주기 위해 메인스레드가 종료하면 소멸자를 호출하게 되고 자신의 핸들스레드가 종료될때까지 기다리게 한다.!!!
 ::CloseHandle( ( HANDLE )( _threadHandle ) ); // 그다음에 메인 스레드를 종료한다.
}
내가 만든 스레드가 돌고 있는 상황에서 메인스레드가
종료 되버리면 에러가 난다.

메인스레드가 종료될때 클래스의 소멸자를 호출하게되면
소멸자에 지금 돌고있는 스레드가 모두 종료될때 까지 기다리게 한다.

스핀락을 사용하는 이유는 리소스를 사용? 대기? 하는 것이 컨텍스트스위칭이 일어나는것보다 빠르기 때문

메인함수에서 소비자와 생산자의 쓰레드가 만들어지도록 호출하고
처리후 메인쓰레드가 종료될때 소멸자가 호출되는데 이 호출되는 순간에도 각자 자신의 쓰레드가 종료되지않고 돌고 있기 때문이다. 해결책은 메인쓰레드가 종료될때 소멸자가 호출되는것을 이용하여 소멸자가 호출되었을대 모든 자식 스레드를 종료할때까지 기다린다. 그다음 메인스레드가 종료되게하면 문제가 해결된다.

::WaitForSingleObject( ( HANDLE )( _thread ), INFINITE);

또한 이 생산자/소비자의 문제에서는 멀티코어에서 생길수 있는 동일 메모리공유 문제에 대해서는 volatile boolean변수로 플래그를 만들어 해결한다.

그러나 이경우에도 생산자와 소비자 서로의 쓰레드가 다르므로 터질가능성이 있다. 이경우에는 소멸자에서 웨이트를 넣어두고 와일루프안에서 이 웨이트를 풀어주게만든다.

::ReleaseMutex(_thread);

결국 플래그와 공유변수에 대한 락으로 해결하게된다.

Producer.h

#pragma once

#include <queue>
#include <string>

#include "Concurrency\Thread.h"
#include "Customer.h"
#include "Concurrency\Timer.h"
#include "Concurrency\SpinLock.h"

class Producer
{
public:
 Producer(float frequency);
 ~Producer();

public:
 void
  beginService();
 bool
  tryPop( std::string * product);
 
private:
 void service();

private:
 Thread * _thread;
 std::queue< std::string > _products;//경쟁관계에 있는 녀석
 Timer _timer;
 float _frequency;
 unsigned int _count;
 volatile bool _isEnd;
 SpinLock mylock;
};

Produce.cpp

#include "StdAfx.h"
#include "Producer.h"

#include <Windows.h>

Producer::Producer(float frequency)//인자를 갖지 않는 생성자를 호출한다 기입하지 않으면, 파라미터를 받는 생성자를 만들었다면 기본생성자는 호출되지않는다.
 : _count( 0 ),
 _isEnd(false),
 _frequency(frequency)
{
 
}

void Producer::beginService()
{
 _thread = new Thread( std::bind(&Producer::service, this));
}

Producer::~Producer(void)
{
 _isEnd = true;
 ::WaitForSingleObject( ( HANDLE )( _thread ), INFINITE); //반드시해주어야함 모든 자식 스레드를 종료해주기 위해 메인스레드가 종료하면 소멸자를
 delete _thread;

 // 메인스레드가 종료될때 소멸자 호출,. 그러나 지금 스레드가 작동중이라면???
 

}

bool Producer::tryPop( std::string * product)
{
 mylock.lock();
 bool result = false;

 if( !_products.empty())
 {
  *product = _products.front();
  _products.pop();
  result = true;
 }
 mylock.unlock();
 return result;

}

void Producer::service()
{ 
 _timer.start();
 
 while( !_isEnd )
 {
   
  if(_timer.elapsedSeconds() >= _frequency)
  {
   
   char number[100];
   itoa( _count, number, 10 );
   
   std::string product = "product";
   product += number;
   ++_count;
   _timer.stop();
   _timer.start();
   mylock.lock();
   _products.push( product );
   mylock.unlock();
  }
  
  ::Sleep(0); //원래는 블록큐로 가나, 0이니까 준비큐로가고 1초가 아닐때 다른작업할거있음 하라고 양보하는 것이다.
 }
 
}

Customer.h
#pragma once

#include "Concurrency\Thread.h"
#include "Concurrency\Timer.h"
#include "Concurrency\MutexLock.h"

class Producer;

class Customer
{
public:
 Customer( Producer * producer, // 포인터 타입으로 갖고 있게 한다. 인스턴스를 선언하지 않고, 클래스실체를 선언하지 않고 사용하는법
        float frequency);
 ~Customer();

public:
 void
  beginService();

private:
 void service();//백그라운드에서
 
 private:
 Thread * _thread;
 Producer * _producer;
 Timer _timer;
 float _frequency;
 volatile bool _isEnd;

};

Customer.cpp
#include "StdAfx.h"
#include <concrt.h>
#include <Windows.h>

#include "Customer.h"

#include "Producer.h"//헤더에서 그냥 선언만해놓고 여기서 추가해주면 사용할수 있다.

Customer::Customer( Producer * producer,
 float frequency)
 : _producer( producer ),
 _frequency( frequency ),
 _isEnd(false)
{

}

Customer::~Customer(void)
{
 _isEnd = true;
 ::WaitForSingleObject( ( HANDLE )( _thread ), INFINITE);
 delete _thread;
}

void Customer::beginService()
{
 _thread = new Thread( std::bind(&Customer::service, this));
}

void
 Customer::service()
{
 _timer.start();

 while( !_isEnd)
 {
  if(_timer.elapsedSeconds() >= _frequency )
  {
   std::string product;

   if( _producer->tryPop(&product)) // 커스토머 쓰레드 호출되는 곳의 쓰레드이다.
   {
 
    printf( "%s\n", product.c_str() );

    _timer.stop();
    _timer.start();
   }

  }
  ::Sleep( _frequency * 250 );
 }
}


ServiceThread.cpp
// ServiceThread.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"

#include<Windows.h>

#include "Customer.h"
#include "Producer.h"
int _tmain(int argc, _TCHAR* argv[])
{
 Producer p(0.01f);
 Customer c1( &p, 0.008);
 Customer c2( &p, 0.005 );

 p.beginService();
 ::Sleep( 2000 );
 c1.beginService();
 c2.beginService();

 Timer timer;
 timer.start();
 while( timer.elapsedSeconds() < 20);

 return 0;
}

// Test1.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

#include "Concurrency/Thread.h"
#include "Concurrency/MutexLock.h"

//이거 연결은 정적 라이브러리 연결 동적이 나올수도 있음

string g_buffer;
MutexLock g_lock; //1000번 찍는데 락을 걸어주기 위해서 우리가 만든 락 클래스를 이용한다.

int _tmain(int argc, _TCHAR* argv[])
{
 vector<Thread * >threads; //힙을 이용하면 new를 이용하면 생성하고 delete를 하면 우리가 생성 소멸 타이밍을 조절 할 수 있다.

 for(int i =0; i < 5; ++i)
 {
  char ch = 'a'+i;
  threads.push_back(new Thread( // 푸시백은 백터 맨뒤에 이것들을 추가하는것
  [ ch ]()->void //[]여기 안에는 클로져 특성을 가지는 변수, 캡쳐할 리스트들 ()인자값이 들어감
  {
   g_lock.lock();
   for(int i =0; i < 1000; ++i)
   {
    g_buffer +=ch;
   }
   g_lock.unlock(); //락을 걸어준다.

  }));
 }
 for_each(threads.begin(), //이것은 외우기
  threads.end(),
  [](Thread * thread)  //포위치로 쓰래드를 처음부터 끝까지 훌터서 지울려고 하는거임
 {
  delete thread; //벡터에는 포인터가 들어있기 때문에 벡터의 원소는 변화가 없다. 쓰레드가 종료 되면 지워버림
 });
   
 cout<<g_buffer<<endl;
 return 0;
}