worker.cancel was called in the main thread. Therefore, Thread.currentThread() inside the cancel method returns the main thread and therefore the interrupt method was called by the main thread. You are not interrupting the worker thread in this case.

I want to interrupt a thread with interrupt() method, however I experience a behaviour I cannot explain.

As indicated in the code, calling the worker method cancel() from MainActivity can’t interrupt the thread, where calling workerThread.interrupt() can.

If the worker calls cancel() by itself it’s interrupting.

Unless the current thread is interrupting itself, which is always permitted, the checkAccess method of this thread is invoked, which may cause a SecurityException to be thrown.

I thought it might be a security exception, cause the UIThread tries to interrupt the workerThread, but its not thrown. And if, it should also be thrown when workerThread.interrupt() is called?

Worker.java

package com.example.threadapp;
public class Worker implements Runnable {

    public void cancel() {
        Log.d("Threading", "call Thread.currentThread().interrupt()");
        try {
            Thread.currentThread().interrupt();
        } catch (SecurityException e) {
            e.printStackTrace();
            Log.d("Threading", "SecurityException while interrupting");
        }

    }

    @Override
    public void run() {
        //
        while(!Thread.currentThread().isInterrupted()) {
            Log.d("Threading", "Worker alive");
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
                cancel();
            }
            //cancel(); //interrupts thread
            //Thread.currentThread().interrupt(); //interrupts thread

        }
        //
        Log.d("Threading", "Worker Thread closing");
    }
}

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private Worker worker;
    private Thread workerThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        worker = new Worker();
        workerThread = new Thread(worker);
        workerThread.start();

        (new Handler(Looper.getMainLooper())).postDelayed(new Runnable() {
            @Override
            public void run() {
                Log.d("Threading", " call worker.cancel()");
                worker.cancel(); //doesn't interrupt thread
                //workerThread.interrupt(); //interrupts thread
            }
        }, 10000);
    }
}