정의 된 간격으로 Android에서 Runnable 스레드를 실행하는 방법은 무엇입니까?

Android 에뮬레이터 화면에 일정한 간격으로 일부 텍스트를 표시하는 응용 프로그램을 개발했습니다. 나는 Handler수업을 사용하고 있습니다. 내 코드의 스 니펫은 다음과 같습니다.

handler = new Handler();
Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");               
    }
};
handler.postDelayed(r, 1000);

이 응용 프로그램을 실행하면 텍스트가 한 번만 표시됩니다. 왜?

귀하의 예에 대한 간단한 해결책은 다음과 같습니다.

handler = new Handler();

final Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");
        handler.postDelayed(this, 1000);
    }
};

handler.postDelayed(r, 1000);

또는 예를 들어 (원래 러너와 함께) 일반 스레드를 사용할 수 있습니다.

Thread thread = new Thread() {
    @Override
    public void run() {
        try {
            while(true) {
                sleep(1000);
                handler.post(this);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

thread.start();

실행 가능 오브젝트를 실행을 위해 메시지 큐로 송신 될 수있는 명령으로 간주하고 해당 명령을 송신하는 데 사용되는 헬퍼 오브젝트로 핸들러를 처리 할 수 ​​있습니다.

자세한 내용은 여기 http://developer.android.com/reference/android/os/Handler.html

new Handler().postDelayed(new Runnable() {
    public void run() {
        // do something...              
    }
}, 100);

나는 매초마다 올바른 업데이트를 위해 Alex2k8의 첫 번째 솔루션을 향상시킬 수 있다고 생각합니다.

1. 원본 코드 :

public void run() {
    tv.append("Hello World");
    handler.postDelayed(this, 1000);
}

2. 분석

• 상기 비용에서, 디스플레이 된 500 배 지연 시간이 500 * T 밀리 초인 후에 tv.append("Hello Word")비용 T 밀리 초를 가정한다
• 장시간 실행하면 지연이 증가합니다

3. 해결책

지연을 피하려면 postDelayed () 순서를 변경하십시오.

public void run() {
    handler.postDelayed(this, 1000);
    tv.append("Hello World");
}

반복 작업을 위해 사용할 수 있습니다

new Timer().scheduleAtFixedRate(task, runAfterADelayForFirstTime, repeaingTimeInterval);

처럼 불러

new Timer().scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {

            }
        },500,1000);

위의 코드는 0.5 초 후에 처음으로 실행 되며 매 초 마다 반복됩니다 (1000)

어디

태스크 는 실행될 메소드입니다.

최초 실행 시간 후

( 실행을 반복하는 시간 간격 )

둘째로

작업을 여러 번 실행하려는 경우 CountDownTimer 를 사용할 수도 있습니다 .

    new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

     public void onTick(long millisUntilFinished) {
      }
      public void onFinish() {
     }
    }.start();

//Above codes run 40 times after each second

그리고 당신은 또한 runnable로 할 수 있습니다. 같은 실행 가능한 방법을 만듭니다

Runnable runnable = new Runnable()
    {
        @Override
        public void run()
        {

        }
    };

그리고이 두 가지 방법으로 부르십시오

new Handler().postDelayed(runnable, 500 );//where 500 is delayMillis  // to work on mainThread

또는

new Thread(runnable).start();//to work in Background 

나는이 전형적인 경우, 즉 일정한 간격으로 무언가를 실행하는 Timer것이 더 적합하다고 생각합니다. 다음은 간단한 예입니다.

myTimer = new Timer();
myTimer.schedule(new TimerTask() {          
@Override
public void run() {
    // If you want to modify a view in your Activity
    MyActivity.this.runOnUiThread(new Runnable()
        public void run(){
            tv.append("Hello World");
        });
    }
}, 1000, 1000); // initial delay 1 second, interval 1 second

사용하면 Timer몇 가지 장점이 있습니다.

• 초기 지연 및 간격은 schedule함수 인수
• 타이머는 간단하게 호출하여 중지 할 수 있습니다 myTimer.cancel()
• 하나의 스레드 만 실행하려면 새 스레드 myTimer.cancel() 를 예약 하기 전에 호출 해야합니다 (myTimer가 null이 아닌 경우).

Handler handler=new Handler();
Runnable r = new Runnable(){
    public void run() {
        tv.append("Hello World");                       
        handler.postDelayed(r, 1000);
    }
}; 
handler.post(r);

Handler.post () 메소드의 문서를 올바르게 이해하면 :

Runnable r이 메시지 큐에 추가되도록합니다. 실행 가능 파일은이 핸들러가 연결된 스레드에서 실행됩니다.

따라서 @ alex2k8에서 제공하는 예제는 올바르게 작동하지만 동일하지 않습니다. where Handler.post()가 사용되는 경우 새 스레드가 작성되지 않습니다 . 당신 은 EDT에 의해 실행될 Runnable스레드에 게시 합니다 . 그 후에는 EDT 만 실행됩니다HandlerRunnable.run() 다른 하지 않습니다.

기억하십시오 : Runnable != Thread.

코 틀린

private lateinit var runnable: Runnable
override fun onCreate(savedInstanceState: Bundle?) {
    val handler = Handler()
    runnable = Runnable {
        // do your work
        handler.postDelayed(runnable, 2000)
    }
    handler.postDelayed(runnable, 2000)
}

자바

Runnable runnable;
Handler handler;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    handler = new Handler();
    runnable = new Runnable() {
        @Override
        public void run() {
            // do your work
            handler.postDelayed(this, 1000);
        }
    };
    handler.postDelayed(runnable, 1000);
}

흥미로운 예는 별도의 스레드에서 카운터 / 스톱워치를 계속 볼 수 있다는 것입니다. GPS 위치도 표시합니다. 주요 활동 동안 사용자 인터페이스 스레드가 이미 있습니다.

발췌 :

try {    
    cnt++; scnt++;
    now=System.currentTimeMillis();
    r=rand.nextInt(6); r++;    
    loc=lm.getLastKnownLocation(best);    

    if(loc!=null) { 
        lat=loc.getLatitude();
        lng=loc.getLongitude(); 
    }    

    Thread.sleep(100); 
    handler.sendMessage(handler.obtainMessage());
} catch (InterruptedException e) {   
    Toast.makeText(this, "Error="+e.toString(), Toast.LENGTH_LONG).show();
}

코드를 보려면 여기를 참조하십시오.

주요 활동의 사용자 인터페이스 스레드와 함께 실행 가능한 GPS 위치 및 현재 시간을 표시하는 스레드 예제

이제 Kotlin에서는 다음과 같이 스레드를 실행할 수 있습니다.

class SimpleRunnable: Runnable {
    public override fun run() {
        println("${Thread.currentThread()} has run.")
    }
}
fun main(args: Array<String>) {
    val thread = SimpleThread()
    thread.start() // Will output: Thread[Thread-0,5,main] has run.
    val runnable = SimpleRunnable()
    val thread1 = Thread(runnable)
    thread1.start() // Will output: Thread[Thread-1,5,main] has run
}

코 루틴과 코 틀린

코 틀린에서는 코 루틴을 사용하여 다음을 수행 할 수 있습니다.

CoroutineScope(Dispatchers.Main).launch { // Main, because UI is changed
    ticker(delayMillis = 1000, initialDelayMillis = 1000).consumeEach {
        tv.append("Hello World")
    }
}

여기서 사용해보십시오 !