Python doesn't support force-killing threads (Python threads are not raw pthreads). The safe, idiomatic way is to:

• Use a threading.Event() to signal cancellation.
• Have the thread check this flag periodically.

Something like:

import threading
import time

stop_event = threading.Event()

def worker():
    print("Thread started")
    for i in range(1000):
        if stop_event.is_set():
            print("Thread exiting due to stop_event")
            return
        time.sleep(1)
    print("Thread finished")

thr = threading.Thread(target=worker)
thr.start()

time.sleep(5)
print("Sending stop signal")
stop_event.set()
thr.join()
print("Main exit")

Safe solution in UNIX for custom input functions

main idea: if you register signal handler (that do nothing) with sigaction() that signal (directed exactly to blocking thread) break blocking call with EINTR in errno. This method will not work with standard python input/output operations because it check this case I don't know how to make cpython function PyErr_CheckSignals() to return True.

Another peculiarity is that thread.native_id is not a pthread_t.

interruptable.c:

#define PY_SSIZE_T_CLEAN
#include <stdio.h>
#include <signal.h>
#include <string.h>

#include <Python.h>

// hook for signal
void hook(int sig) {
    //printf("i am hook of %zx\n",(size_t)pthread_self());
}

// custom read function, return str
static PyObject* read_line(PyObject *self, PyObject *args) {
    char buf[100];
    //printf("start read()\n");
    char * x;
    Py_BEGIN_ALLOW_THREADS
    x = fgets(buf, sizeof(buf),stdin);
    Py_END_ALLOW_THREADS
    //printf("stop read()\n");
    if (!x) {
        Py_RETURN_NONE; // EOF или ошибка
    }
    return PyUnicode_FromString(buf);
}

// set signal hook via sigaction
// and return pthread_self() as bytes
static PyObject* get_pthread(PyObject* self, PyObject* args) {
    struct sigaction sa, osa;
    sa.sa_handler = hook;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_INTERRUPT;
    if(sigaction(SIGUSR1,&sa,&osa)==-1){
        fprintf(stderr,"failed to setup signal hook\n");
        exit(1);
    }

    pthread_t t = pthread_self();
    //printf("return pthread %zx\n",(size_t)t);
    return PyBytes_FromStringAndSize((const char *)&t, (Py_ssize_t)sizeof(t));
}

// send SIGUSR1 to thread described by first argument 
// as pthread_t, serialised in bytes
static PyObject *
thread_kill(PyObject *self, PyObject *args)
{
    const char *buf;
    Py_ssize_t buflen;

    if (!PyArg_ParseTuple(args, "y#", &buf, &buflen))
        return NULL;

    if (buflen != sizeof(pthread_t)) {
        PyErr_Format(PyExc_ValueError,
                     "Invalid size: got %zd bytes, expected %zu",
                     buflen, sizeof(pthread_t));
        return NULL;
    }

    pthread_t t;
    memcpy(&t, buf, sizeof(pthread_t));

    printf("send SIGUSR1 to %zx\n",(size_t)t);
    int ret = pthread_kill(t, SIGUSR1);
    if (ret != 0) {
        PyErr_Format(PyExc_OSError,
                     "pthread_kill failed with code %d", ret);
        return NULL;
    }

    Py_RETURN_NONE;
}

static PyMethodDef MyMethods[] = {
    {"get_pthread", get_pthread, METH_NOARGS, 
        "Return raw bytes of pthread_self() (memcpy of pthread_t)."},
    {"thread_kill", thread_kill, METH_VARARGS,
     "Send SIGUSR1 to pthread represented by bytes."},
    {"read_line", read_line, METH_NOARGS, "Read a line from stdin"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    "interruptable", // Имя модуля
    NULL,
    -1,
    MyMethods
};

PyMODINIT_FUNC PyInit_interruptable(void) {
    return PyModule_Create(&mymodule);
}

setup.py:

# python3 setup.py build_ext --inplace
from setuptools import setup, Extension

setup(
    name="interruptable",
    ext_modules=[
        Extension("interruptable", ["interruptable.c"])
    ]
)

kill_thread.py:

import threading
import ctypes
from time import sleep
import interruptable

# pthread_t serialised as bytes
# represent thr2
thr2_pthread = None

# standard python trick:
def raise_in_thread(tid, exctype):
    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
        ctypes.c_long(tid),
        ctypes.py_object(exctype)
    )
    if res == 0:
        raise ValueError("Invalid thread ID")
    elif res > 1:
        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), None)
        raise SystemError("PyThreadState_SetAsyncExc failed")

def thread2():
    global thr2_pthread
    thr2_pthread = interruptable.get_pthread()
    print(f"thread2 start reading")

    print(interruptable.read_line())

    print("thread2 ends")

# create and run thread
thr2 = threading.Thread(target=thread2)
thr2.start()

# wait 2 secnds
sleep(2)

if thr2.is_alive():
    #print("killing thr2")
    raise_in_thread(thr2.ident, SystemExit)
    # send signal to thread
    interruptable.thread_kill(thr2_pthread)
thr2.join()
print("main exit")

I've also tryed to pthread_cansel(). It cancel thread without segfaults, but at end program still waits something