Android Support Annotations 라이브러리를 활용한 결함 탐지방법

1. Annotations 이란 ?

 - Annotation 은 Java 코드에서 추가할 수 있는 메타데이터로, @ 기호로 시작한다.

 - 상위 클래스의 메서드를 오버라이드 한다는 정보를 표현하는 @Override 애너테이션이 대표적이다.

 - 추가 정보를 문법적으로 표현할 수 있기 때문에 Java 에서는 API의 의도를 애너테이션으로 명시하고 결함 탐지에 활용하는 기법이 발달 했다.

 

2. Java 에서 제공되는 Annotations

 - @Override : 함수 Override 일 경우에 사용되는 Annotations

 - @Deprecated : 해당 변수, 함수 명이 삭제될 수 있음을 나타낼 때 사용

 - @SuppressWarnings : 권장하지 않는 구문에 대하여 노랑색으로 경고를 표시해 주는 경우

 

3. Android Support Library 의 Annotations

build.gradle 에 아래의 코드를 추가하면 사용 가능하다.

dependencies {

   compile 'com.android.support:support-annotations:20.0.0'

}

 

3.1 @StringRes, @DrawableRes, @ColorRes

위 세가지의 Annotations 는 리소스 아이디 관련 애너테이션이다. 요소의 값이 이 애너테이션들이 의미하는 리소스 타입에 해당하는 리소스 아이디임을 의미한다.

Android 의 모든 리소스는 R 클래스에 의해 int 타입의 아이디로 관리된다. 그래서 drawable 타입 리소스의 아이디를 넣어야 할 곳에 문자열 리소스의 아이디나 정수 값을 넣는 등 실수를 범할 수 있는데, 이 애너테이션을 이용하면 실수를 방지할 수 있다.

void setMessage(@StringRes int resId) {  
    mMessage = mContext.getText(resId);
}

// ...

setMessage(R.string.error_retry);    // OK

int stringId = R.string.error_retry;  
setMessage(stringId);                // OK

setMessage(R.color.white);           // ERROR: Expected resource of type string  
setMessage(1);                       // ERROR: Expected resource of type string 

 

3.2 @ColorInt

@ColorInt 이너테이션은 해당 값이 0xff99ff99와 같은 ARGB 컬러 정수임을 나타낸다. 글자가 비슷한 @ColorRes 애너테이션은 R.color.divider 와 같은 Color Drawable 타입 리소스의 아이디를 나타내므로 혼동하지 않도록 주의한다.

다음 코드는 int 타입 파라미터의 값을 @ColorInt 애너테이션과 @ColorRes 애너테이션으로 명확하게 구분한 예이다.

void setColor(@ColorInt int color) {  
    mColor = color;
}

void setColorRes(@ColorRes int resId) {  
    setColor(mContext.getResources().getColor(resId));
}

// ...

setColor(0xff99ff99);         // OK  
setColor(R.color.divider);    // ERROR: Should pass resolved color instead of resource id  
                              //        here: `getResources().getColor(R.color.divider)`

setColorRes(0xff99ff99);      // ERROR: Expected resource of type color  
setColorRes(R.color.divider); // OK  

 

3.3 @IntRange, @FloatRange

@IntRange 애너테이션 @FloatRange 애너테이션은 숫자형 값의 범위를 한정한다. from 파라미터와 to 파라미터를 지니며, 값의 범위는 from 파라미터의 값부터 to 파라미터의 값 사이다. 투명도에서 0~1 범위의 소숫값(decimal)을 사용하는지, 색상 표현에서 0~255 범위의 정숫값을 사용하는지 혼동하기 쉬운데, 이런 경우에 유용하게 쓰일 수 있다. @IntRange 애너테이션은 int 타입뿐만 아니라 long 타입에도 사용할 수 있다. 마찬가지로 @FloatRange 애너테이션은 float 타입뿐만 아니라 double 타입에도 사용할 수 있다.

다음 코드는 @FloatRange 애너테이션으로 alpha 파라미터의 값이 0.0~1.0이어야 함을 나타내는 예다.

void setAlpha(@FloatRange(from=0.0, to=1.0) float alpha) {  
    // if (alpha < 0 || alpha > 1.0f) {
    // throw new IllegalArgumentException();
    // }
}

// ...

setAlpha(0.5f); // OK  
setAlpha(127);  // ERROR: Value must be ≥ 0.0 and ≤ 1.0 (was 127)  

 

3.4 @UiThread, @WorkerThrea

@UiThread 애너테이션 @WorkerThread 애너테이션, 은 스레드 관련 애너테이션이다. 이 애너테이션들이 의미하는 스레드와 동일한 유형의 스레드에서만 해당 메서드를 호출할 수 있도록 제약한다.

@WorkerThread
void backgroundJob() {  
}

@UiThread
void uiJob() {  
}

// ...

@WorkerThread
void backgroundJob2() {  
    backgroundJob();                  // OK
    uiJob();                          // ERROR: Method uiJob must be called from the UI
                                      // thread, currently inferred thread is worker
    view.setVisibility(View.VISIBLE); // ERROR: Method setVisibility must be called from
                                      // the UI thread, currently inferred thread is
                                      // worker
}

@UiThread
void uiJob2() {  
    backgroundJob();                  // ERROR: Method backgroundJob must be called from
                                      // the worker thread, currently inferred thread is
                                      // UI
    uiJob();                          // OK
    view.setVisibility(View.VISIBLE); // OK
}

 

3.5 @CallSuper

@CallSuper 애너테이션은 이 애너테이션이 붙은 메서드를 하위 클래스에서 오버라이드할 때는 반드시 상위 클래스의 메서드를 호출하도록 강제한다. 액티비티의 라이프사이클 메서드에도 사용된다.

다음 코드는 foo() 메서드에 @CallSuper 애너테이션을 붙여 foo() 메서드를 오버라이드한 하위 클래스에서 반드시 super.foo() 메서드를 호출하도록 강제하는 예다.

 

class Super {  
    @CallSuper
    void foo() {
    }

    void bar() {
    }
}

// ...

class Example1 extends Super {  
    @Override
    void foo() {                // ERROR: Overriding method should call 'super.foo'
    }

    @Override
    void bar() {                // OK
    }
}

class Example2 extends Super {  
    @Override
    void foo() {                // OK
        super.foo();
    }

    @Override
    void bar() {                // OK
        super.bar();
    }
}

class ExampleActivity extends Activity {  
    protected void onCreate(Bundle saved) { // ERROR: Overriding method should call
                                            //        'super.onCreate'
    }
}

 

3.6 @NonNull, @Nullable

 

@NonNull 애너테이션 @Nullable 애너테이션은 null 값 처리에 관련된 애너테이션이다.

@NonNull 애너테이션은 값이 'null'이 아니라는 것을 나타낸다. 예를 들어 @NonNull 애너테이션이 붙은 변수에 null 값을 대입하면 경고가 나타난다.

@Nullable 애너테이션은 값이 'null'일 수 있다는 것을 나타낸다. 예를 들어 @Nullable 애너테이션이 붙은 변수를 null 검사 없이 사용하면 경고가 나타난다.

다음 코드는 필드, 파라미터, 메서드에 @NonNull 애너테이션과 @Nullable 애너테이션을 사용한 예다.

 

class Example {  
    @NonNull
    final Context mContext;
    @Nullable
    View mView;

    Example(@NonNull Context context) {
        // context 파라미터에 @NonNull 애너테이션이 붙어 있으므로
        // 파라미터의 값이 null이 아닐 것이라 가정한다.
        // 그래서 null 검사가 필요 없다.
        // if (context == null) {
        // throw new NullPointerException("context");
        // }
        mContext = context;
    }

    @NonNull
    Context getContext() {
        return mContext;
    }

    void setView(@Nullable View view) {
        mView = view;
    }

    @Nullable
    View getView() {
        return mView;
    }
}

// ...

Context context = null;  
new Example(context);        // WARNING: Argument 'context' might be null

new Example(null);           // WARNING: Passing 'null' argument to parameter annotated as @NonNull

new Example(nonNullContext); // OK

View view = getView();  
view.getTag();               // WARNING: Method invocation 'view.getTag()' may produce  
                             // 'java.lang.NullPointerException'

@NonNull View mView;
mView = getView();           // WARNING: Expression 'getView()' might evaluate to null but  
                             // is assigned to a variable that is annotated with @NonNull

 

http://d2.naver.com/helloworld/8725603

http://thdev.net/616

'Android' 카테고리의 다른 글

[AndroidStudio] git clone 방법  (0) 2023.05.27

Android PowerManager.WakeLock

 

일반적으로 Android 는 애플리케이션이나 서비스에 전력이 필요하지 않으면 CPU도 전력을 소모하지 않게 설계되어 있습니다.

따라서 화면이 꺼진 뒤 일정 시간이 지나면 CPU 가 딥 슬립(deep sleep) 상태로 전환됩니다.

딥 슬립 상태로 전환되면 백그라운드에서 동작하는 서비스도 CPU를 사용하지 못하기 때문에, 아래와 같은 일이 발생할 수 있습니다.

1. BroadcastReceiver 클래스의 onReceive() 메서드가 호출 되었지만, 관련 로직을 수행하지 않음.

2. AlarmManager 클래스를 사용하여 트리거가 발생 하였지만, CPU 가 실행상태가 아니므로 이후 로직을 사용하지 않음.

 

이를 방지하기 위해 Android 에서는 PowerManager.WakeLock 클래스를 제공하여 CPU가 딥 슬립상태에서 실행 상태로 전환되어 유지될 수 있도록 합니다. 다만, Device 의 베터리 수명은 이 API 를 어떻게 사용하느냐에 따라 크게 달라지기 때문에, PowerManager.WakeLock 은 정말 필요한 경우가 아니면 사용하지 말아야 하고, 만약 사용 하더라도 가능한 최소 수준을 사용하고, 최대한 빨리 release 해주어야 합니다.

WakeLock 을 사용하기 위한 API 는 newWakeLock() 입니다. 이 함수는 PowerManager.WakeLock object 를 생성 합니다. 이 객체를 사용하여 Device 의 Power 를 제어할 수 있습니다.

Application 에서 이를 사용하는 방법은 아주 간단 합니다.

PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
 PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, "My Tag");
 wl.acquire();
   ..screen will stay on during this section..
 wl.release();

newWakeLock 에 사용되는 Flag 의 종류는 아래와 같이 4가지가 있습니다.

PARTIAL_WAKE_LOCK 을 사용하면 스크린 상태에 관계 없이, 사용자가 전원 버튼을 눌러 단말을 sleep 시켜도 계속 CPU는 실행상태에 있습니다.

다른 PARTIAL_WAKE_LOCK 을 제외한 다른 Flag 를 사용하면 사용자가 전원버튼을 눌렀을 때 CPU는 sleep 상태로 들어갈 수 있습니다.

 

WakeLock 클래스의 로직은 IOS 미만 버전과 이상 버전의 로직이 다릅니다.

IOS 이전에는 WakeLock.acquire(timeout) 메서드에 치명적인 문제점이 존재하는데, 이 메서드는 timeout 시간만큼 CPU 를 사용하고 나면 자동으로 WakeLock.release() 메서드가 호출되어 CPU 사용을 마칩니다. 그런데 timeout 시간보다 먼저 작업이 끝나서 명시적으로 WakeLock.release() 메서드를 호출 하더라도 timeout 시간이 지나면 다시한번 WakeLock.release() 메서드가 호출되는데, 그러면 이미 CPU 사용을 마쳤는데도 다시한번 CPU 사용을 마치려 시도하면서 충돌이 발생합니다.

 

FATAL EXCEPTION: main  
java.lang.RuntimeException: WakeLock under-locked  
    at android.os.PowerManager$WakeLock.release(PowerManager.java:307)
    at android.os.PowerManager$WakeLock.release(PowerManager.java:282)
    at android.os.PowerManager$WakeLock$1.run(PowerManager.java:202)
    at android.os.Handler.handleCallback(Handler.java:587)
    at android.os.Handler.dispatchMessage(Handler.java:92)
    at android.os.Looper.loop(Looper.java:130)
    at android.app.ActivityThread.main(ActivityThread.java:3691)
    at java.lang.reflect.Method.invokeNative(Native Method)
    at java.lang.reflect.Method.invoke(Method.java:507)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:847)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:605)
    at dalvik.system.NativeStart.main(Native Method)

충돌이 발생하는 원인을 살펴보기 위해 WakeLock.acquire(timeout) 메서드의 코드를 살펴보면, 다음과 같이 postDelayed() 메서드를 사용하여 timeout 시간 뒤에 mReleaser 객체가 호출되게 됩니다. mReleaser 객체는 Runnable 객체로, WakeLock.release() 메서드를 호출합니다.

/**
 * Makes sure the device is on at the level you asked when you created
 * the wake lock. The lock will be released after the given timeout.
 * 
 * @param timeout Release the lock after the give timeout in milliseconds.
 */
public void acquire(long timeout) {
    synchronized (mToken) {
        acquireLocked();
        mHandler.postDelayed(mReleaser, timeout);
    }
}
private final Runnable mReleaser = new Runnable() { 1254 public void run() { 1255 release(); 1256 } 1257 };

왜 postDelated() 메서드에 의해서 충돌이 발생하는지 ICS 미만 버전과 ICS 이상 버전에 있는 PowerManager.java 의 소스코드를 살펴보면 알 수 있습니다.

ICS 미만 버전의 PowerManager.java 에서 release() 메서드의 코드는 다음과 같습니다.

public void release(int flags)  
{
    synchronized (mToken) {
        if (!mRefCounted || --mCount == 0) {
            try {
                mService.releaseWakeLock(mToken, flags);
            } catch (RemoteException e) {
            }
            mHeld = false;
        }
        if (mCount < 0) {
            throw new RuntimeException("WakeLock under-locked " + mTag);
        }
    }
}

 

위 두 소스 코드를 비교해 보면 ICS 이상 버전에 removeCallbacks(mRelease) 메서드가 추가된 것을 볼 수 있습니다 .

이처럼 timeout 시간보다 먼저 release() 메서드가 호출되었을 때에는 timeout 시간이 지난 뒤 다시한번 release() 메서드가 호출되지 않도록 하여 충돌이 발생하지 않습니다.

Handler.removeCallbacks() 메서드는 postDelayed() 메서드를 통해 메시지 큐에 등록된 Runnable 객체를 삭제합니다.

 

WakeLock  효율적으로 사용하기

WakeLock 은 배터리에 가장 영향을 많이 끼치는 기능 중 하나이므로, 사용할 수 밖에 없는 상황이라면 최대한 효율적으로 사용해야 합니다.

WakeLock 을 효율적으로 사용하는 방법은 다음과 같습니다.

 

1. 어떤 동작을 수행하려고 WakeLock 을 사용했다면 동작이 종료되었을 때 바로 release() 메서드를 호출한다.

2. 연산이 끝나면 항상 release() 메서드가 호출되고 Exception 등으로 인해 release() 메서드가 호출되지 못하는 일이 없도록 finally 키워드를 사용한다.

3. 패킷 발신, 수신에 사용한다면 발신할 때 한번 수신할때 다시한번 WakeLock을 호출 하여 두번의 호출이 생긴다. 만약 발신 후 수신까지 시간이 매우 짧다면 WakeLock.acquire(timeout) 메서드를 사용하여 호출 횟수를 줄일 수 있다.

4. 화면이 켜진 상태라면 CPU는 딥슬립 모드로 전환되지 않기 때문에 화면이 꺼진 상태에서만 WakeLock 을 사용하고, 화면이 켜진 상태에서는 WakeLock 을 사용하지 않는 것도 좋은 방법이다.

5. BroadcastReceiver 클래스를 사용하는 경우에도 onReceive(...) 메서드 이후의 로직이 언제나 정상적으로 수행되게 하기 위해서 WakeLock 을 사용한다. 하지만 Android Support Library 를 사용하면 WakefulBroadcastReceiver 클래스를 사용하여 직접 WakeLock 을 호출하지 않아도 된다.

 

 

WakefullBroadcastReceiver 클래스는 startWakefulService() 메서드로 서비스 (주로 IntentService) 에 처리해야 할 작업을 전달 해주고, 이러한 전달 과정에서 단말이 딥 슬립 상태로 돌아가지 않도록 내부적으로 PARTIAL_WAKE_LOCK 을 획득 합니다. 서비스에서 작업이 완료 되면 completeWakefullIntent() 메서드를 호출하여 WakeLock 사용을 종료하게 됩니다.

 

 

기존에는 그냥 연습용 앱이어서 해상도 별로 이미지를 생각하지 않고 drawable 에 다 때려 넣었다.

그러다보니 여러명에서 같이 하는 앱개발의 경우에, 각기 다른 Android Device 를 가지고 있어서, OutOfMemory  error 가 나는 경우가 많았다.

그래서 찾아봤는데 아래 사이트에서 각 해상도별 이미지를 생성 해준다.

https://romannurik.github.io/AndroidAssetStudio/nine-patches.html#&sourceDensity=320&name=example

 

Android Asset Studio - Simple nine-patch generator

Drag or select a source graphic to get started.

romannurik.github.io

 

생성된 이미지를 아래와 같이 적용해주기만 하면 된다.

splash_logo.png

 

그리고 불러다 쓸때는 기존에 @drawble/splash_logo 가 아닌 @mipmap/splash_logo 라고 해주면, 알아서 돌아가는 device 에 맞게 이미지를 로드 해준다. 

<ImageView
    android:id="@+id/splash_img"
    android:layout_width="0dp"
    android:layout_height="290dp"
    android:scaleType="fitCenter"
    android:contentDescription="@string/contentDescription_img"
    app:layout_constraintWidth_percent="0.7"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintHorizontal_bias="0.5"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintVertical_bias="0.276"
    app:srcCompat="@mipmap/splash_logo" />

 

굿굿 

1. File > New > Project from Version Control... 선택

 

2. Clone 하고자 하는 repository 의  URL 입력

'Android' 카테고리의 다른 글

Anotation  (0) 2024.11.10

waitpid 함수는 wait 함수처럼 자식 프로세스를 기다릴때 사용하는 함수입니다. 즉, 자식 프로세스의 종료상태를 회수할 때 사용합니다.

하지만 waitpid 함수는 자식 프로세스가 종료될 때 까지 차단되는 것을 원하지 않을 경우, 옵션을 사용하여 차단을 방지할 수 있습니다.

그리고 기다릴 자식 프로세스를 좀더 상세히 지정할 수 있습니다.


#include <sys/wait.h>

 pid_t waitpid(pid_t pid, int *statloc , int options);

 성공 : 프로세스 ID 반환

 오류 : -1 



waitpid 함수의 첫번째 인자에 대해서 알아 보겠습니다.

 wiatpid 함수의 첫 번째 인자

 의미

  pid가 -1 일 경우  (pid ==  -1)

   임의의 자식 프로세스를 기다림

  pid가 0 보다 클 경우 (pid > 0)

   프로세스 ID가 pid인 자식 프로세스를 기다림

  pid가 -1 보다 작을 경우 (pid < -1)

  프로세스 그룹 ID가 pid의 절댓값과 같은 자식 프로세스를 기다림

 pid가 0일 경우 (pid == 0)

 waitpid를 호출한 프로세스의 프로세스 그룹 PID와 같은 프로세스 그룹 ID를 가진 프로세스를 기다림 

waitpid 함수의 오류(-1)는 지정한 pid의 프로세스 또는 프로세스 그룹이 없는 경우에 발생하며 그리고 pid가 자식 프로세스가 아닐 때 발생합니다.


두번째 인자에 대해서 알아 보겠습니다.

 

 waitpid 함수 반환 값

 두 번째 인자 인 statloc 값

 자식 프로세스가 정상적으로 종료

 프로세스 ID

 - WIFEXITED(statloc) 매크로가 true를 반환

 - 하위 8비트를 참조하여 자식 프로세스가 exit, _exit, _Exit에 넘겨준 인자값을 얻을 수 있음, WEXITSTATUS(statloc)

  자식 프로세스가 비정상적으로 종료

 프로세스 ID

 - WIFSIGNALED(statloc) 매크로가 true를 반환

 - 비정상 종료 이유를 WTERMSIG(statloc) 매크로를 사용하여 구할 수 있음

 waitpid 함수 오류  -1

 - ECHILD : 호출자의 자식 프로세스가 없는 경우

 - EINTR : 시스템 콜이 인터럽트 되었을 때


세번째 인자에 대해서 알아 보겠습니다.

 세 번째 인자로 사용가능한 상수

 의미 

 WCONTINUED

 중단 되었다가 재개된 자식 프로세스의 상태를 받음

 WNOHANG 

 기다리는 PID가 종료되지 않아서 즉시 종료 상태를 회수 할 수 없는 상황에서 호출자는 차단되지 않고 반환값으로 0을 받음

 WUNTRACED 

 중단된 자식 프로세스의 상태를 받음


아래 예제는 세 번째 인자에 아무것도 주지 않았을 때 wait 함수와 동일한 동작하는 것을 확인해 보겠습니다.

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int main() { pid_t childPid; int status; childPid = fork(); if(childPid > 0) { // 부모 프로세스 int ret; printf("부모 PID : %ld, pid : %d\n",(long)getpid(), childPid); sleep(3); ret = waitpid(childPid,&status,0); // 세번째 인자에 0을 넣었으므로 wait 함수와 동일한 동작을 함 printf("부모 종료 %d %d %d\n",ret,WIFEXITED(status),WEXITSTATUS(status)); exit(0); } else if(childPid == 0){ // 자식 코드 printf("자식 시작 PID : %ld\n", (long)getpid()); sleep(8); printf("자식 종료\n"); exit(0); } else { // fork 실패 perror("fork Fail! \n"); return -1; } return 0; }


실행 결과를 보겠습니다.

부모 PID : 13444, pid : 13445

자식 시작 PID : 13445

자식 종료

부모 종료 13445 1 0 

부모 프로세스는 3초 동안 동작하고 자식 프로세스는 8초 동안 동작하는 예제 코드입니다. 하지만 결과는 자식 프로세스가 먼저 종료되고 부모 프로세스가 종료되었습니다.

waitpid 함수는 세번째 인자로 0을 주었기 때문에 자식 프로세스가 종료될 때 까지 blocking 되었기 때문입니다.

WIFEXITED 매크로는 1(true)를 리턴하였으며 WEXITSTATUS는 자식 프로세스가 0을 리턴 한 것을 알려주고 있습니다.


다음 예제는 세 번째 인자에 WNOHANG 옵션을 넣어보도록 하겠습니다.

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int main() { pid_t childPid; int status; childPid = fork(); if(childPid > 0) { // 부모 프로세스 int ret; printf("부모 PID : %ld, pid : %d\n",(long)getpid(), childPid); sleep(3); ret = waitpid(childPid,&status,WNOHANG); // WNOHANG 옵션을 사용하면 자식 프로세스가 종료되지 않았을 경우 blocking 되지 않고 즉시 0값을 리턴합니다. printf("부모 종료 %d %d\n",ret,WIFEXITED(status)); exit(0); } else if(childPid == 0){ // 자식 코드 printf("자식 시작 PID : %ld\n", (long)getpid()); sleep(8); printf("자식 종료\n"); exit(0); } else { // fork 실패 perror("fork Fail! \n"); return -1; } return 0; }

실행 결과를 확인해 보겠습니다.

부모 PID : 14289, pid : 14290

자식 시작 PID : 14290

부모 종료 0 0 127

자식 종료 

waitpid 함수는 0을 리턴하였으며 WIFEXITED 매크로도 false를 리턴하였습니다. WNOHANG 옵션을 사용하였기 때문에 자식 프로세스가 종료될 때 까지 기다리지 않고 waitpid 함수가 바로 0값을 리턴하였기 때문입니다.


마지막으로 존재하지 않는 자식 프로세스의 PID를 waitpid 첫 번째 인자로 넣어 보겠습니다.

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #include <sys/error.h> #include <sys/string.h> int main() { pid_t childPid; int status; childPid = fork(); if(childPid > 0) { // 부모 프로세스 int ret; printf("부모 PID : %ld, pid : %d\n",(long)getpid(), childPid); sleep(3); ret = waitpid(99999,&status,WNOHANG); // pid로 99999(존재하지 않는 프로세스 ID) printf("부모 종료 %d %d %s\n",ret,errno,strerror(errno)); // 오류가 발생하였을 경우 errno값을 확인 exit(0); } else if(childPid == 0){ // 자식 코드 printf("자식 시작 PID : %ld\n", (long)getpid()); sleep(8); printf("자식 종료\n"); exit(0); } else { // fork 실패 perror("fork Fail! \n"); return -1; } return 0; }

실행 결과를 보도록 하겠습니다.

부모 PID : 17859, pid : 17860

자식 시작 PID : 17860

부모 종료 -1 10 No child processes

자식 종료 

waitpid 함수는 -1 오류 값을 반환하였습니다. 그리고 에러 넘버(errno) 10, 즉 NO child processes라는 에러를 출력하였습니다. 

99999라는 자식 프로세스가 존재하지 않는다는 의미입니다. 그 이유는 waitpid 함수의 첫 번째 인자로 존재하지 않는 99999 PID값을 입력하였기 때문입니다.


지금까지 wait 함수보다 좀더 다양한 기능을 제공하는 waitpid 함수에 대해서 알아 보았습니다.

오늘은 근거리 무선 통신기술인 NFC(Near Field Communication) 에 대해 알아보겠습니다.

NFC 는 13.56MHz 주파수 대역을 사용해 데이터를 주고 받는 근거리 무선 통신기술 중의 한 종류입니다.

이렇게 이야기하면 어려운 개념 같지만, 실제로 우리는 스마트폰에서 NFC 기술을 자주 접하고 있습니다.

NFC 를 이용해서 스마트폰끼리 간단한 Text 나 URL 정보등을 교환할 수 있고, NFC 태그에 스마트폰을 접촉하면 저장되어 있는 정보들을 읽어들일 수 있습니다.

그래서 요즘에는 명함에도 NFC 기능이 탑재되어, 간단히 태그만 하더라도 스마트폰으로 그 명함에 적혀있는 이름이나 핸드폰 번호를 간단하게 읽어들일 수 있습니다.

무선통신 종류 별로 Speed 와 Range 를 살펴보면, NFC 의 경우 10cm 이하의 거리에서 굉장히 느린 속도로 데이터를 주고 받을 수 있는 프로토콜이라고 볼 수 있습니다.

그렇기 때문에 간단한 Text 만을 전송하는데 주로 사용되는데,  예를들어 카드번호/전화번호/특정 URL Link 등을 전송하는데 주로 사용 됩니다.

그에 대비해서 Bluetooth 의 경우는 30m 이하. 즉, NFC 보다는 비교적 먼 거리에서의 통신이 가능 합니다.

데이터 전송 속도도 느린 편에 속하고 있지만, NFC 보다는 2배 가까이 빠른 속도를 가집니다.  저화질의 사진 정도는 전송할 수 있는 수준입니다.

우리가 비교적 많이 사용하고 있는 Wi-Fi 의 경우 최대 100Mbs 정도의 속도로 Multimedia 컨텐츠도 전송 할 수 있는 수준입니다.  위 표에 표기된 무선통신 프로토콜 중에는 WiFi 의 속도가 가장 빠른 것으로 확인 되네요.

 

NFC 는 굉장히 다양한 분야에 활용되고 있습니다. 제일 많이 사용되는 분야가 '결제' 시스템인데,

스마트폰에 기본으로 탑재되어있는 NFC 기능을 이용하여 교통카드/신용카드/각종 페이 간편결제 등으로 활용할 수 있습니다.

 

LG전자에서 2013년에 출시한 '트롬' 세탁기에도 NFC 기능이 탑재되었는데,

예를들어 사용자가 스마트폰 앱에서 원하는 세탁 코스를 선택한 후 스마트폰을 세탁기의 NFC 태그에 접촉 하게 되면

즉시 해당 코스가 세탁기에 저장되어 제품에 탑재된 기본 12가지 세탁코스 외에도 다양한 세탁코스를 사용할 수 있습니다.


삼성전자에서 나온 프린터에도 NFC 기능이 탑재되어

별도로 컴퓨터를 킬 필요 없이, 스마트폰에 저장된 문서를 프린터에 부탁된 NFC 태그에 터치만 해도 바로 프린트가 된다고 합니다.


최근 평창동계올림픽에서도 NFC 방식의 결제 시스템이 도입되었는데,

스티커나 배지, 장갑의 형태로 카드나 지갑 없이도 간단히 몸에 부착해 결제가 가능한 것이 특징입니다.

스티커의 경우 3,5,10,20 만원이 충전된 형태로, 배지와 장갑은 3,5 만원이 충전된 형태로 구매할 수 있었으며,

간단한 Tag 만으로 결제가 가능 하도록 NFC 기능이 도입되었습니다.


NFC 스티커는 가격도 저렴하여 400원 정도로 인터넷에서 쉽게 구매할 수 있기 때문에

여러 기능들을 실현해 보기 쉬운 방법 중 하나인 것 같습니다.

 

다음 포스팅에서는 실제 Android 에서 NFC Tag 를 Read 하고 Write 하는 방법에 대해 알아보도록 하겠습니다.

 

앞선 포스팅에서는 Internal/External 저장소에 사용자의 데이터를 저장하는 방법에 대해 살펴 보았습니다.

오늘은 데이터베이스를 활용하여 원하는 데이터를 저장하는 방법에 대해 알아보겠습니다.

Intenrnal/External 저장소에 저장하는 것 보다 데이터베이스를 이용하여 저장할 때는, 동일한 형태의 데이터를 저장할 수 있다는 점에서 더 편리합니다.

회원정보를 저장할 경우가 대표적인 예인데, 이 경우 회원의 이름, 성별, 전화번호, 주소 등등이 각각 DB의 속성(Attribute) 가 될 것이고,

실제 들어가는 데이터 (김태희, 여, 010-0000-0000, 경기도.. ) 들이 값(Value) 이 될 것입니다.

 

1. SQLiteOpenHelper 를 이용한 DB 생성

SQLiteOpenHelper Class 는 Database 를 생성하고 해당 Database 의 Version 을 관리합니다.

해당 Class 를 사용하기 위해서 Database가 처음 생성될 때 불리는 onCreate(..) 와 Database 가 Upgrade 될 경우에 불리는 onUpgrade(..) callback method 를 구현해 주어야 하며, 필요에 따라 onOpen(..) 함수와 onDowngrade(..) 함수도 구현하여 사용할 수 있습니다.

저는 SQLiteOpenHelper를 상속 받은 MySQLiteOpenHelper 를 생성해서 간단하게 onCreate/onUpgrade 만 구현해 주었습니다.

 

public class MySQLiteOpenHelper extends SQLiteOpenHelper {

    private final String TAG = "MySQLiteOpenHelper";

    public MySQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase) {
        String sql = "create table student (_id integer primary key autoincrement, name text, age integer, address text)";
        sqLiteDatabase.execSQL(sql);
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
        String sql="drop table if exists student";
        sqLiteDatabase.execSQL(sql);
        onCreate(sqLiteDatabase);
    }
}

 

onCreate 에서는 Database를 생성해 주었고, 각 Field 는 name, age, address 로 구성될 수 있도록 하였습니다.

"create table student (_id integer primary key autoincrement, name text, age integer, address text)";

위 Query 로 DB생성 후 실제 만들어진 DB 를 열어보면 다음과 같이 data 가 저장됩니다.

 

그리고 onUpgrade 함수에는 현재 생성되어있는 Database 를 지우고 onCreate 를 통해 다시 생성될 수 있도록만 구현을 해 두었습니다.

 

2. DB에 데이터 삽입 및 삭제

DB에 데이터 삽입/삭제를 위해 MyDBHandler 클래스를 생성하였습니다.

MyDBHandler 클래스에서는 DBActivity 로 부터 사용자 정보를 받아 MySQLiteOpenHelper 로 전달 합니다.

데이터를 저장 할 때 ContentValues 를 이용했는데, ContentValues 는 Data 를 Key와 Value의 Set 으로 저장할 수 있습니다.

그래서 Database 에 값을 줄때 "name, 홍길동" ,"age, 24" 등과 같이 Key 와 Value 의 형태로 쉽게 전달 가능합니다.

 

public class MyDBHandler {

    private final String TAG = "MyDBHandler";

    SQLiteOpenHelper mHelper = null;
    SQLiteDatabase mDB = null;

    public MyDBHandler(Context context, String name) {
        mHelper = new MySQLiteOpenHelper(context, name, null, 1);
    }

    public static MyDBHandler open(Context context, String name) {
        return new MyDBHandler(context, name);
    }

    public Cursor select()
    {
        mDB = mHelper.getReadableDatabase();
        Cursor c = mDB.query("student", null, null, null, null, null, null);
        return c;
    }

    public void insert(String name, int age, String address) {

        Log.d(TAG, "insert");

        mDB = mHelper.getWritableDatabase();

        ContentValues value = new ContentValues();
        value.put("name", name);
        value.put("age", age);
        value.put("address", address);

        mDB.insert("student", null, value);

    }

    public void delete(String name)
    {
        Log.d(TAG, "delete");
        mDB = mHelper.getWritableDatabase();
        mDB.delete("student", "name=?", new String[]{name});
    }

    public void close() {
        mHelper.close();
    }
}

select 함수는 Database 의 전체 내용을 return 해주고, insert/delete 함수는 각각 Database에 데이터를 추가/삭제 시 호출 됩니다.

delete 의 경우 name 을 인자로 받아서 이름이 동일 하면 해당 row 를 모두 삭제하도록 하였습니다.

 

3. 동작 확인

기존에 작성하였던 MainActivity 에 Database 버튼을 하나 추가한다음에, 이 버튼을 눌렀을 때 Activity 를 전환하여 Database 의 내용을 뿌려주도록 하였습니다.

가장 상단에는 Database 에 내용을 추가할 수 있도록 Editbox 를 3개 두었고, 각각 이름/나이/주소 정보를 저장할 수 있도록 하였습니다.

Update Database 를 누르게 되면 Editbox 에 추가한 내용이 Database 에 업데이트 되고 리스트의 내용이 업데이트 됩니다.

리스트의 각 항목을 롱클릭 하게 되면 해당 Field 가 삭제 됩니다. ^^

    

여기까지 Database 를 이용한 아주 간단한 사용자 데이터 저장에 대해서 살펴보았습니다.

모든 소스는 https://github.com/bettercho/MyGithub/tree/master/storeuserdata 를 참고하시면 됩니다. 

 

안드로이드 어플리케이션 개발 중, external 저장 공간에 있는 파일을 read 또는 write 하려고 할 때 아래와 같이 에러가 발생하는 경우가 있습니다.

02-10 14:20:45.310 30711-30711/com.example.codetravel.musicplayer W/System.err: java.io.FileNotFoundException: /storage/emulated/0/john.mp3: open failed: EACCES (Permission denied)
02-10 14:20:45.343 30711-30711/com.example.codetravel.musicplayer W/System.err:     at libcore.io.IoBridge.open(IoBridge.java:452)
02-10 14:20:45.343 30711-30711/com.example.codetravel.musicplayer W/System.err:     at java.io.FileInputStream.<init>(FileInputStream.java:76)
02-10 14:20:45.343 30711-30711/com.example.codetravel.musicplayer W/System.err:     at android.media.MediaPlayer.setDataSource(MediaPlayer.java:1095)
02-10 14:20:45.343 30711-30711/com.example.codetravel.musicplayer W/System.err:     at android.media.MediaPlayer.setDataSource(MediaPlayer.java:1046)
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err:     at com.example.codetravel.musicplayer.MusicPlayerActivity.onPlayPause(MusicPlayerActivity.java:45)
...
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err: Caused by: android.system.ErrnoException: open failed: EACCES (Permission denied)
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err:     at libcore.io.Posix.open(Native Method)
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err:     at libcore.io.BlockGuardOs.open(BlockGuardOs.java:186)
02-10 14:20:45.344 30711-30711/com.example.codetravel.musicplayer W/System.err:     at libcore.io.IoBridge.open(IoBridge.java:438)

02-10 14:20:45.345 30711-30711/com.example.codetravel.musicplayer W/System.err:     ... 15 more 


open failed: EACCES (Permission denied) 에러가 발생하는 이유는 external 저장 공간의 파일에 대해서 read 또는 write 하기 위해서는 별도의 권한이 필요하기 때문입니다.

권한을 부여하는 방법은 AndroidManifest.xml 파일에 아래와 같이 read, write 권한을 기입하면 됩니다.

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

위치는 <manifest> 안에 그리고 <application> 밖에 선언하면 됩니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.codetravel.musicplayer">

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <!-- 여기에 추가해 줍니다 -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> <!-- 여기에 추가해 줍니다 -->

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MusicPlayerActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>

</manifest> 


그리고 어플리케이션을 install 한 후, setting 메뉴의 해당 app으로 가서 storage 권한을 enable 해주면 에러는 사라지게 됩니다.

Internal 저장 공간과 External 저장 공간의 특징에 대해서는 Android 데이터 저장 방법 - Internal/External Storage 포스팅에 자세히 설명되어 있습니다.

이번 포스팅에서는 고아 프로세스와 좀비 프로세스에 대해서 알아 보도록 하겠습니다.


고아 프로세스와 좀비 프로세스 정의는 아래와 같습니다.

부모 프로세스가 자식 프로세스보다 먼저 종료되면 자식 프로세스는 고아프로세스가 됩니다.

그리고 자식 프로세스가 종료되었지만 부모 프로세스가 자식 프로세스의 종료 상태를 회수하지 않았을 경우에 자식 프로세스를 좀비 프로세스라고 합니다.


1. 고아 프로세스

부모 프로세스가 자식 프로세스보다 먼저 종료되면 init 프로세스가 자식 프로세스 새로운 부모 프로세스가 됩니다.

종료되는 프로세스가 발생할 때 커널은 이 프로세스가 누구의 부모 프로세스인지 확인한 후, 커널이 자식 프로세스의 부모 프로세스 ID를 1(init 프로세스)로 바꿔 줍니다.

간단한 예제를 통해서 고아 프로세스의 부모 프로세스가 init 프로세스로 바뀌는지 확인해 보도록 하겠습니다.


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    
    pid_t childPid;
    int i;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        printf("부모 PID : %ld, pid : %d\n",(long)getpid(), childPid);
        sleep(2);
        printf("부모 종료\n");
        exit(0);
    }
    else if(childPid == 0){  // 자식 코드
        printf("자식 시작\n");
        
        for(i=0;i<10;i++) {
            printf("자식 PID : %ld 부모 PID : %ld\n",(long)getpid(), (long)getppid());
            sleep(1);
        }
        
        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}



실행 결과는 아래와 같습니다.

 

자식 프로세스의 원래 부모 프로세스는 PID 46797 였으나 부모 프로세스가 종료 된 후에는 1로 바뀐 것을 볼 수 있습니다.

init 프로세스는 유닉스 계열의 운영체제에서 부팅 과정 중 생성되는 최초의 프로세스이며 시스템이 종료될때까지 계속 살아있는 데몬 프로세스입니다.

그리고 init 프로세스의 PID는 일반적으로 1입니다. 

고아 프로세스가 작업을 종료하면 init 프로세스가 wait함수를 호출하여 고아 프로세스의 종료 상태를 회수함으로써 좀비 프로세스가 되는것을 방지합니다.


2. 좀비 프로세스

반대로 자식 프로세스가 부모 프로세스 보다 먼저 종료되는 경우가 있습니다. 

자식 프로세스가 exit 시스템 콜을 호출 하면서 종료되면 이 프로세스에 관련된 모든 메모리와 리소스가 해제되어 다른 프로세스에서 사용할 수 있게 됩니다.

자식 프로세스가 종료된 이후에 부모 프로세스가 자식 프로세스의 상태를 알고 싶을 수 있기 때문에 커널은 자식 프로세스가 종료되더라도 최소한의 정보(프로세스 ID, 프로세스 종료 상태 등)를 가지고 있게 됩니다.

부모 프로세스가 좀비 프로세스의 종료상태를 회수하게 되면(wait 시스템콜을 호출을 통하여)  좀비 프로세스는 제거됩니다.

간단한 예제 코드를 보도록 하겠습니다.


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


int main() {
    
    pid_t childPid;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        printf("부모 PID : %ld, pid : %d\n",(long)getpid(), childPid);
        sleep(30);
        printf("부모 종료\n");
        exit(0);
    }
    else if(childPid == 0){  // 자식 코드
        printf("자식 시작 PID : %ld\n", (long)getpid());
        sleep(1);
        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}


터미널 창에 아래와 같이 명령어를 입력합니다.

ps aux | grep 'Z' 명령어를 사용하여 좀비 프로세스를 출력합니다.


좀비 프로세스가 쌓이게 되면 리소스의 유출을 야기할 수 있기 때문에 좀비 프로세스 상태를 오래 유지되지 않도록 부모프로세스는 wait 시스템 콜 함수를 사용하여 자식 프로세스의 종료 상태를 읽어들이는 것이 필요합니다.

부모 프로세스가 fork() 함수를 사용하여 자식 프로세스를 생성하였을 때, fork() 함수가 리턴되는 시점부터 2개의 프로세스가 동작하게 됩니다.

부모 프로세스가 자식 프로세스의 종료 상태를 얻기 위해서는 wait() 함수를 사용합니다.

다른 말로 표현하면 wait() 함수를 사용하여 자식 프로세스가 종료 될 때까지 기다릴 수 있습니다.


wait() 함수는 아래와 같이 동작합니다.

1. 자식 프로세스가 동작 중이면 호출 차단이 차단되기 때문에 상태를 얻어올 때까지 대기

2. wait() 함수 호출자가 시그널을 받을 때까지 대기

3. 자식 프로세스가 종료된 상태라면 즉시 호출이 반환되어 상태를 얻음, 이 때 wait() 함수는 자식 프로세스의 프로세스 ID를 반환

4. 자식 프로세스가 없다면 호출이 즉시 반환되며, 에러값을 반환


 #include <sys/wait.h>

 pid_t wait(int *statloc);

 성공 : 프로세스 ID 반환

 오류 : -1


자식 프로세스가 정상 종료되었을 때와 비정상 종료 되었을 때, wait() 함수의 반환값과 statloc 인자값이 다르게 채워집니다.


 

 wait 함수 반환 값

 statloc  값

 자식 프로세스가 정상적으로 종료

 프로세스 ID

 - WIFEXITED(statloc) 매크로가 true를 반환

 - 하위 8비트를 참조하여 자식 프로세스가 exit, _exit, _Exit에 넘겨준 인자값을 얻을 수 있음, WEXITSTATUS(statloc)

  자식 프로세스가 비정상적으로 종료

 프로세스 ID

 - WIFSIGNALED(statloc) 매크로가 true를 반환

 - 비정상 종료 이유를 WTERMSIG(statloc) 매크로를 사용하여 구할 수 있음

 wait 함수 오류  -1

 - ECHILD : 호출자의 자식 프로세스가 없는 경우

 - EINTR : 시스템 콜이 인터럽트 되었을 때


예제를 통하여 살펴 보도록 하겠습니다.


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>

int main() {
    
    pid_t childPid;
    int status,i;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        pid_t waitPid;
        printf("부모 PID : %ld, pid : %d %d \n",(long)getpid(), childPid, errno);
        
        for(i=0;i<5;i++) {
            sleep(1);
        }
        
        waitPid = wait(&status);
        
        if(waitPid == -1) {
            printf("에러 넘버 : %d \n",errno);
            perror("wait 함수 오류 반환");
        }
        else {
            if(WIFEXITED(status)) {
                printf("wait : 자식 프로세스 정상 종료 %d\n",WEXITSTATUS(status));
            }
            else if(WIFSIGNALED(status)) {
                printf("wait : 자식 프로세스 비정상 종료 %d\n",WTERMSIG(status));
            }
        }
        
        printf("부모 종료 %d %d\n",waitPid,WTERMSIG(status));
    }
    else if(childPid == 0){  // 자식 프로세스
        printf("자식 PID : %ld \n",(long)getpid());

        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}


fork를 한 후에, 부모 프로세스는 5초간 sleep을 하였기 때문에 wait 함수를 호출하기 전에 자식 프로세스는 종료된 상태입니다.

따라서  wait 함수를 호출하면 자식 프로세스의 상태를 즉시 반환 받을 수 있습니다.


실행 결과를 보겠습니다.

자식 프로세스는 정상 종료 되었으며 WEXISTSTATUS(status) 매크로를 사용하여 자식 프로세스가 반환한 0값을 얻어왔습니다.

부모 PID : 34989, pid : 34999 0 

자식 PID : 34999 

자식 종료

wait : 자식 프로세스 정상 종료 0

부모 종료 34999 0


이번에는 자식 프로세스에 sleep 함수로 지연을 발생시켜서 부모 프로세스가 wait() 함수를 호출하였을 때 자식 프로세스가 종료될 때까지 대기하도록 만들어 보겠습니다.


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>

int main() {
    
    pid_t childPid;
    int status,i;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        pid_t waitPid;
        printf("부모 PID : %ld, pid : %d %d \n",(long)getpid(), childPid, errno);
        
        waitPid = wait(&status);
        
        if(waitPid == -1) {
            printf("에러 넘버 : %d \n",errno);
            perror("wait 함수 오류 반환");
        }
        else {
            if(WIFEXITED(status)) {
                printf("wait : 자식 프로세스 정상 종료 %d\n",WEXITSTATUS(status));
            }
            else if(WIFSIGNALED(status)) {
                printf("wait : 자식 프로세스 비정상 종료 %d\n",WTERMSIG(status));
            }
        }
        
        printf("부모 종료 %d %d\n",waitPid,WTERMSIG(status));
    }
    else if(childPid == 0){  // 자식 코드
        printf("자식 PID : %ld \n",(long)getpid());
        
        for(i=0;i<5;i++) {
            sleep(1);
        }
        
        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}


자식 프로세스가 5초 동안 동작하는 동안 부모 프로세스는 wait() 함수를 호출하여 자식 프로세스의 종료 상태를 얻기 위해 대기합니다.

실행 결과를 살펴 보도록 하겠습니다.

기대했던 것과 다르게 wait함수는 -1를 반환하였습니다. 에러의 원인을 찾기 위해 errno 출력과 perror 함수를 이용하였습니다.

부모 PID : 35650, pid : 35660 0 

자식 PID : 35660 

자식 종료

에러 넘버 : 4 

wait 함수 오류 반환: Interrupted system call

부모 종료 -1 126 

"Interrupted system call" 에러 문구가 wait 함수가 성공하지 못한 이유를 알려주고 있습니다.

Advanced Programming in the UNIX Environment 도서에 10.5 절에 나와 있듯이 유닉스 계열의 시스템에서는 '느린' 시스템 호출에 의해 차단되어 있는 도중에 신호를 잡으며 그 시스템호출이 가로채입니다. 이런 경우 시스템 호출 함수는 errno를 EINTR로 설정하고 오류를 반환합니다.

wait() 함수는 시스템 콜 함수이며  '느린' 시스템 콜 함수에 속합니다.


이 문제를 해결하기 위해서는 오류 반환을 검사하여 오류가 발생한 시스템 콜 함수를 다시 호출하는 방법을 사용합니다.

"Interrupted system call" 오류가 발생하더라도 wait함수를 재실행할 수 있도록 아래와 같이 코드를 수정합니다.

while문을 사용하여 wait 함수가 -1 값을 반환하고 errno 값이 EINTR일 경우에 wait함수를 재실행하도록 코드를 추가하였습니다.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>

int main() {
    
    pid_t childPid;
    int status,i;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        pid_t waitPid;
        printf("부모 PID : %ld, pid : %d %d \n",(long)getpid(), childPid, errno);
        
        while((((waitPid = wait(&status)) == -1) && errno == EINTR));  // 에러 발생시 명시적으로 처리하고 wait 함수를 재호출함
        
        if(waitPid == -1) {
            printf("에러 넘버 : %d \n",errno);
            perror("wait 함수 오류 반환");
        }
        else {
            if(WIFEXITED(status)) {
                printf("wait : 자식 프로세스 정상 종료 %d\n",WEXITSTATUS(status));
            }
            else if(WIFSIGNALED(status)) {
                printf("wait : 자식 프로세스 비정상 종료 %d\n",WTERMSIG(status));
            }
        }
        
        printf("부모 종료 %d %d\n",waitPid,WTERMSIG(status));
    }
    else if(childPid == 0){  // 자식 코드
        printf("자식 PID : %ld \n",(long)getpid());
        
        for(i=0;i<5;i++) {
            sleep(1);
        }
        
        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}


실행 결과를 보도록 하겠습니다.

부모 프로세스는 자식 프로세스가 5초 동안 실행되는 동안  wait 함수로 대기하였다가 자식 프로세스가 종료되는 순간 정상적으로 종료 상태를 얻어 왔습니다.

즉 자식 프로세스가 반환한 값 0을 얻은것을 확인 할 수 있습니다.

부모 PID : 37460, pid : 37470 0 

자식 PID : 37470 

자식 종료

wait : 자식 프로세스 정상 종료 0

부모 종료 37470 0 


마지막으로 자식 프로세스를 kill 명령어로 종료시켜 보도록 하겠습니다.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>

int main() {
    
    pid_t childPid;
    int status,i;
    
    childPid = fork();
    
    if(childPid > 0) {  // 부모 프로세스
        pid_t waitPid;
        printf("부모 PID : %ld, pid : %d %d \n",(long)getpid(), childPid, errno);
        
        while((((waitPid = wait(&status)) == -1) && errno == EINTR));
        
        if(waitPid == -1) {
            printf("에러 넘버 : %d \n",errno);
            perror("wait 함수 오류 반환");
        }
        else {
            if(WIFEXITED(status)) {
                printf("wait : 자식 프로세스 정상 종료 %d\n",WEXITSTATUS(status));
            }
            else if(WIFSIGNALED(status)) {
                printf("wait : 자식 프로세스 비정상 종료 %d\n",WTERMSIG(status));
            }
        }
        
        printf("부모 종료 %d %d\n",waitPid,WTERMSIG(status));
    }
    else if(childPid == 0){  // 자식 코드
        printf("자식 PID : %ld \n",(long)getpid());
        
        for(i=0;i<100;i++) { // 충분히 긴 시간 동안 자식 프로세스를 동작 시키놓고 kill 명령어로 종료시켜 봅니다
            sleep(1);
        }
        
        printf("자식 종료\n");
        exit(0);
    }
    else {  // fork 실패
        perror("fork Fail! \n");
        return -1;
    }
    
    return 0;
}


예제 코드를 실행 한 후,

자식 프로세스는 100초 동안 동작을 할 것입니다.

그리고 부모 프로세스는 wait() 함수를 통해 자식 프로세스의 종료 상태를 얻기위해 대기 중입니다.

부모 PID : 40272, pid : 40275 0 

자식 PID : 40275  


100초가 지나기 전에 터미널에서 아래와 같이 명령어를 입력하도록 하겠습니다.

40275는 자식 프로세스의 프로세스 ID입니다.

kill -9 40275 

위 명령어를 입력하는 부모 프로세스에서 호출한 wait()함수는 반환되면서 아래의 정보를 출력하게 됩니다.

부모 PID : 40272, pid : 40275 0 

자식 PID : 40275 

wait : 자식 프로세스 비정상 종료 9

부모 종료 40275 9 

자식 프로세스는 동작중에 kill 명령어에 의해서 비정상 종료 되었고 시그널 값은 9을 전달 받았습니다.


지금까지 wait함수를 사용하여 부모 프로세스가 자식 프로세스의 종료 상태(정상 또는 비정상)를 얻는 과정을 살펴 보았습니다.

그리고 시스템 콜 함수를 사용할 때 발생하는 오류에 대해서도 알아 보았습니다.

+ Recent posts