Python3 Tkinter DBのデータ抽出をキャンセルしたい

Question

TkinterでPostgreSQLにあるデータを表示します。
ただ、取得するにはどうしても時間がかかってしまいます。
その取得中にデータの取得を中断したいことがあります。

そこでTkinterのボタンを押したら、SELECT文の処理を中断したいのですが可能ですか？

GUIの前提として、DBのデータの表示・追加・変更・削除を想定しているので、DB処理中は処理中であることを示すフレームを最前面に表示し他の画面の操作を不可とします。処理が終わったら、処理前のフレームを最前面に戻します。
下記のソースコードのように。
想定では、"Processing now." のフレームにボタンを付けて、SELECTをキャンセルしたいです。

import time
import tkinter as tk
from tkinter import ttk

def on_button1():
    frame0.tkraise()
    frame0.update()
    long_process()
    frame1.tkraise()

def long_process():
    time.sleep(1)

if __name__ == "__main__":
    root = tk.Tk()

    root.grid_rowconfigure(0, weight=1)
    root.grid_columnconfigure(0, weight=1)
    
    frame0 = ttk.Frame(root)
    frame1 = ttk.Frame(root)
    frame0.grid(row=0, column=0, sticky=tk.NSEW)
    frame1.grid(row=0, column=0, sticky=tk.NSEW)

    frame1.tkraise()
    
    text0 = "Processing now."
    label0 = tk.Label(frame0, text=text0)
    label0.pack(anchor=tk.CENTER, expand=1)

    text1 = "Button"
    button1 = ttk.Button(frame1, text=text1, command=on_button1)
    button1.pack(anchor=tk.CENTER, expand=1)
    
    root.mainloop()

ただ、上のコードではDB操作を試みるとアプリが固まってボタンの操作もできなくなるので、過去の質問の回答にある実装方法に変えるつもりでいます。（GUIを動かすメインスレッドとは別のスレッドをガン回しする）

追記

メモ

psycopg2のキャンセルサンプル。
ボタン1を押すと、SELECTクエリ実行。ボタン2を押すと、クエリ中断。
（これを画面遷移と組み合わせるのが課題）

import queue
import threading
import time
import tkinter as tk
from tkinter import ttk

import psycopg2


def monitor_variable1():
    global monitor_flag1, gval1

    while monitor_flag1:
        try:
            data = gval1.get_nowait()
        except queue.Empty as e:
            pass
        except Exception as e:
            print(e, type(e))
        else:
            if data == "SELECT":
                threading.Thread(target=select, daemon=True).start()
            elif data == "CANCEL":
                threading.Thread(target=cancel, daemon=True).start()

        time.sleep(0.1)


def monitor_variable2():
    global monitor_flag2, gval2

    while monitor_flag2:
        try:
            data = gval2.get_nowait()
        except queue.Empty as e:
            pass
        except Exception as e:
            print(e, type(e))
        else:
            pass

        time.sleep(0.1)


def select():
    global con, cur

    print("select()")

    try:
        with psycopg2.connect(
            host = "192.168.0.100",
            user = "user01",
            password = "pass01",
            dbname = "testdb"
        ) as con:

            with con.cursor() as cur:
                print("SQL...")
                sql = "SELECT * FROM testview;"
                cur.execute(sql)
                results = cur.fetchall()
                print("rows: {}".format(len(results)))

    except psycopg2.errors.QueryCanceled as e:
        print("cancel")

    except Exception as e:
        print(type(e), e)
    
    finally:
        con = None
        cur = None


def cancel():
    global con

    print("cancel()")

    if con:
        con.cancel()


def on_button1():
    global gval1

    gval1.put("SELECT")


def on_button2():
    global gval1

    gval1.put("CANCEL")


def on_close():
    global monitor_flag1, monitor_flag2, con

    if con:
        return

    monitor_flag1 = False
    monitor_flag2 = False
    thread1.join()
    thread2.join()
    root.destroy()


if __name__ == "__main__":
    gval1 = queue.Queue()
    gval2 = queue.Queue()
    monitor_flag1= True
    monitor_flag2= True
    con = None
    cur = None

    thread1 = threading.Thread(target=monitor_variable1)
    thread2 = threading.Thread(target=monitor_variable2)
    thread1.start()
    thread2.start()

    root = tk.Tk()

    button1 = ttk.Button(root, text="Button1", command=on_button1)
    button1.grid()

    button2 = ttk.Button(root, text="Button2", command=on_button2)
    button2.grid()

    root.protocol("WM_DELETE_WINDOW", on_close)
    root.mainloop()

Comments

[dameo]

ちゃんと設計し、最小限のコードで「できない」という説明をしましょう。
それすらしていないのに質問してる時点でもう丸投げと同じです。

PostgreSQLは pg_cancel_backend でクエリを止められます(要権限)。
https://www.postgresql.org/docs/15/functions-admin.html#FUNCTIONS-ADMIN-SIGNAL

[dameo]

GUIはスレッド間で同期を取ってアクセスすればいいだけですよ。UIをいじるスレッドを1つだけにして、時間のかかる処理はワーカースレッドにやらせる、というのがセオリーです。同期はteamiklさんのおっしゃるようにキューを使うのが汎用ですが、別にスレッドをjoinするだけで良ければそこまでする必要もありません。
何が「出来ない」のか明確に最小限のコードで表しましょう。

Answer 1

中断自体は可能ですが、そのようにプログラムの設計自体を見直す必要があります。

ここでの「処理の中断」には、2つのトピックがあります。

• Python の処理の中断
• DB のクエリの中断

time.sleep() が時間のかかる処理だと思いますが、
現状のコードの構成で中断する手段は long_process関数 の内容次第です。

• 別スレッドにする ... スレッドの中断はプラットフォーム依存。PythonのThreadでは未対応。
  時間のかかるループ内に中断フラグを設ける実装が必要。
• 別プロセスにする ... プロセスの強制終了 (kill)
• 非同期処理 (asyncio等) ... プログラムの大幅な設計見直しが必要
• シグナルを使った割り込み・中断 (プラットフォーム依存)
• 実行に時間のかかる関数をジェネレーターとして実装し、タイマーで分割して実行

加えて、GUIを応答なしにさせないようにするには、
イベントハンドラーで呼ばれる関数は即時に抜けて、
GUIのイベントループ側に処理を戻さなければなりません。

---

DBのクエリの中断については、Python のDB APIの範囲外の為、
各DB・ライブラリにより対応状況が異なります。
(例: psycopgライブラリであれば、connectionクラスのcancelメソッド)

対応してない場合は、別プロセスにしてプロセスを強制終了というのが
ライブラリに依存しない実装手段です。

---

質問の要点を、時間のかかる処理の中断とされてるようですすが
内容の詳細次第では、全く別の解決策が取れる場合もあります。

例えば、極端な例を挙げると
数万件規模のデータを全て表示したい場合などは、

• メモリには限りがあり、一度に格納できる件数には限りがある
• 画面サイズにも限りがあるので、一度に表示できる件数は限られる

といった制約があるため、解決策の候補には
時間のかかるクエリ自体を発行せずに、クエリ自体を分割する手法もあります。

この辺りは、時間のかかる処理の内容次第なので、
より良い解決策が必要な場合は、具体的な詳細を記載してください。（データ件数の規模など）

Comments

[person]

回答ありがとうございます。

時間のかかる処理は、DBの抽出～DBデータのGUI反映等を暫定的にtime.sleep()で表現しているだけです。

DBのライブラリはpsycopg2を使う予定です。cancelメソッド知りませんでした。ドキュメントで確認してみます。

DB絡みのレスポンスの悪さについては、大量のデータがDBに保存されているかつwindowsPC, raspberry piなどを数百台同時に無線接続で使うなどの想定によるものです。ここは回避できないです。（有線にしたり、損失の低いケーブル使う等極力レスポンスの悪さを改良する策もあるにはありますが、ソフト的にもある程度対応できていたい。）

1台に表示するデータの件数は多くないです。いろいろなテーブルのデータを表示しますが、最大でも1画面に50レコード前後ぐらいです（複数のテーブルを結合したビューを参照）。

[teamikl]

クライアント側で所得する件数が多くないのであれば、
課題は時間がかかった時の timeout 処理ですね。

追記のコードに関しては、
gval はリストですが、マルチスレッドで使う場合は
同期キューを使いましょう。(標準ライブラリの queue モジュール)

複数のスレッドから同時アクセスした際の挙動に問題があり、
小さなテストプログラムでは発生しないが、実運用した際には
問題の再現が難しい不具合の原因となりえます。

====

スレッドの使い方を以下のように
スレッドA: DB接続・切断、CANCEL, SELECT 等の命令を待ち受ける
スレッドB: SELECT した際にクエリを発行する作業用スレッド

スレッドA はいつでも CANCEL を待ち受け出来るようにしておきます。

データ受け渡し用の queue は、GUI -> DB と DB -> GUI の２つが必要です。
キューA: SELECT, CANCEL 等の命令を送る
キューB: DB の所得結果を GUI のスレッドへ送る

GUI 側でのキューの読み出しは、get_nowait を使い、キューが空の場合は例外を捕捉します。
注意: get だとブロッキング処理なので、キューが空の時にGUIが応答なしになります。

追記：過去の質問のリンク先のコメントにサンプルコード投稿有

====
DBのクエリ中断について

https://www.psycopg.org/docs/connection.html#connection.cancel
https://www.postgresql.org/docs/current/libpq-cancel.html#LIBPQ-PQCANCEL

マルチスレッドで安全に使えるかどうかの情報について、抜粋すると

> You can call this function from a different thread than the one currently executing a database operation

> PQcancel can safely be invoked from a signal handler

DB用スレッドを一つにすることもできますが、難易度は少し上がります。

- シグナルハンドラで割り込む
- OSのselect システムコールを使ったタイムアウト (ドキュメントの Advanced topics)

プラットフォームによっては使えない場合もあり。

[person]

すみません。
キューについては過去の質問でそのように回答頂いていましたね。
追記コードを修正しました。

スレッドについてですが、DBの接続・クエリ・切断とキャンセルを同じにしてしまうと、同じwhileで条件分岐することになるため、クエリを実行してから終了するまでキャンセルを受け付けられませんでした。
そのため、追記したコードのように別のスレッドにしました。
これは改善策あるのでしょうか？

回答にあるスレッドAは都度生成するイメージでしょうか？

[teamikl]

> クエリを実行してから終了するまでキャンセルを受け付けられませんでした。

スレッドAはコマンドの受け取りのみで、実際の処理はそのループ内では行いません。
スレッドAのループではいつでもコマンドを受け付けられるようにして、
SELECT クエリ発行はスレッドBで処理するようにします。

＞回答にあるスレッドAは都度生成するイメージでしょうか？

複数回のSELECT を許容するかどうかにもよりますが、
スレッドBを SELECT の度に生成する感じです。

このスレッドは稼働中にプログラムが終了すると、スレッドが残り続けることがあるので、
daemon スレッドのフラグを設定しておくと良いです。

[person]

> 複数回のSELECT を許容するかどうかにもよりますが、
> スレッドBを SELECT の度に生成する感じです。

SELECTやINSERT、UPDATE、DELETEを複数回呼ぶこともある想定です。

あと、DB処理中にウィンドウの×を押してアプリ終了されるのは避けたいので（タスクマネージャー等で強制終了はやむなしで見逃す）、queue使ってスレッドの中で無限ループをガン回しにして、閉じるときにjoin()呼ぶようにした方が良いでしょうか？

[teamikl]

> SELECTやINSERT、UPDATE、DELETEを複数回呼ぶこともある想定です。

クエリの同時発行を許容するかどうかにもよりますが、

- メインスレッド (GUI)
- GUIからのコマンド(CANCEL, SELECT 等) 待ち受け スレッド
- DB へのクエリ (SELECT, INSERT, UPDATE, DELETE)

メインスレッド以外に２つのスレッドを準備して、
それぞれのスレッド間をqueue でやりとりします。

DBの中断手段は、２通り（どちらか）
A: GUIからのコマンド待ち受けスレッドから、conn.cancel() を呼ぶ
B: DB用のスレッドでシグナルハンドラを設定して、シグナルを送る。

通常のマルチスレッドであれば、スレッドに関連するリソースの生存期間の管理の都合、
DDへのアクセスはDBのスレッドからのみ行うように設計したい所ですが、
conn.ccancel メソッドのみは、例外的に別スレッドやシグナルハンドラから呼んでも
安全なように設計されてます。

まずは A の実装方法を検討してみてください。
B の方法は、DBへのアクセスを単一スレッドからのみにできるので、
クラス・モジュールを有効に使う設計では役に立つかもしれませが、
シグナルの挙動に関して、プラットフォーム間で違いが出る場合があります。

----
> （タスクマネージャー等で強制終了はやむなしで見逃す）

シグナルハンドラで補足できる場合があります。(※ windows以外)
強制終了時にスレッドが残り続けないようにするには、
スレッドのdaemonフラグをTrueにしておくと良いです。

> queue使ってスレッドの中で無限ループをガン回しにして、閉じるときにjoin()呼ぶようにした方が良いでしょうか

おおむねその通りですが、join 前に、ループを確実に抜けるようにしておきます。
ループが阻害されるケースはいくつかあって、それぞれに対応が必要です

- queue が空の時、queue.get で処理が止まっている → queue に適当な終了用のメッセージをいれる
- queue が詰まっていて、終了メッセージ読み取りまで時間がかかる -> ループ毎に終了フラグをチェック
- time.sleep で長期間スリープ中 -> スレッドでは threading.Event.wait を使う。キャンセル可能なsleep
- 時間のかかる for ループを実行中 → 定期的に終了フラグをチェックし、ループを抜ける

GUIを閉じる(root.destroy)前に join すると GUI が応答なしになるので、その点も注意。

[person]

思い違いのため、返信の内容を変更しました。

> まずは A の実装方法を検討してみてください。

追記メモの内容を変更しました。
この認識で合ってますか？

-----
（ごめんなさい、Button1とButton2を相互に連打したら<class 'AttributeError'> 'NoneType' object has no attribute 'fetchall'出てしまいました。追記メモは残しますが見直してみます。

-----
スレッド使っているので、if con: 辺りを修正する必要がありそうです･･･。

[teamikl]

> 追記メモの内容を変更しました。
> この認識で合ってますか？

変更点が追えないのですが、スレッドは２，３個固定で済みます。
SELECT を別スレッドで実行 ... ok
CANCEL を別スレッドで実行 ... 不要です
間違いではないが、無駄に冗長になっている箇所。

スレッドを用いたサンプルコードは過去の質問のコメント欄に載せてます。

今回の質問の要点は、時間のかかるクエリの実行・中断なので
解決策は、
- 時間のかかる処理を別スレッドで実行するように変更 ... ここはクリア。応答なし状態は解消しているはずです。
- con.cancel() に当たる部分を呼び出す。... "CANCEL" を受け取った時にその場で実行で構いません。
　念のため注意点を書いておくと、con.cancel() 呼び出し自体は
　別スレッドから呼び出しても安全ですが、
　con 自体がタイミングによって None になる可能性があります。
　if con: の時点で None でなくても、その直後に None になる、等。

[person]

Noneはtry-exceptで、できるときだけcancel()するでもいいですかね。

[teamikl]

マルチスレッドでは、タイミングに起因する問題は
問題の再現がとても難しいので、極力そのような構造は排除した方が良いです。
（長期間稼働した後や、ある特定条件でのみ発生したり、他の人が問題を再現できなくて、デバッグが困難になる傾向があります）

２つ以上のスレッドから共通のリソースにアクセスする場合、
if con: と con.cancel() の間に con = None が同時発生しないように
双方で threading.Lock 等を用いて排他制御を行います。

[person]

相互連打で
<class 'psycopg2.ProgrammingError'> no results to fetch
も発生。おそらく原因は同じだと思います。

ロックする場合、下記のように値変えている部分だけロックすれば良いでしょうか？
with threading.Lock():
con = None
cur = None

[person]

lock = threading.Lock()

with lock:
con = None
cur = None

with lock:
if con:
con.cancel()

キャンセルにもロック付けたが、button1, button2 連打で下記例外発生。
<class 'AttributeError'> 'NoneType' object has no attribute 'execute'
<class 'AttributeError'> 'NoneType' object has no attribute 'fetchall'

[teamikl]

> 値変えている部分だけロックすれば良いでしょうか？

いいえ。
execute, fetchall メソッドがないと言われているので、
別の場所で起こった例外です。

但し、fetchall のループ全体をロック内にすると、
ロックが解除されるまでcancel が実行されなくなるので、中断処理を阻害してしまう点に注意。

[person]

> 但し、fetchall のループ全体をロック内にすると、
> ロックが解除されるまでcancel が実行されなくなるので、中断処理を阻害してしまう点に注意。

そうなんですよね。そのため、conとcurをNoneに戻すときだけをロックしたつもりなのですが･･･。

作りを変える必要があるのでしょうか？

Answer 2

回答ではありません

tkは多くの人には不要であり、本質的でもないので、省いています。dockerとpython3が使えるLinux環境を想定したpsycopg2によるpostgres14へのアクセスとクエリのキャンセル処理のサンプルを置いておきます。python部分はtkがないことを除き質問者さんのものと似たようなものです。
環境構築にはvenvを使っています。

環境構築スクリプト

空のディレクトリから、sh create_env.shなどとして動かせばOKです。

create_env.sh

docker run -d --rm -e POSTGRES_PASSWORD=pass -v $(pwd)/data:/var/lib/postgresql/data -p 5432:5432 --name postgres_$$ postgres:14-alpine
python3 -m venv env
. ./env/bin/activate
pip install -U pip
pip install -U setuptools
pip install psycopg2-binary
cat >hoge.py <<EOF
import psycopg2
from threading import Thread
from time import sleep
def cancel(t, con):
    sleep(t)
    con.cancel()
with psycopg2.connect(
        host = "localhost",
        user = "postgres",
        password = "pass",
        dbname = "postgres"
    ) as con:
    with con.cursor() as cur:
        try:
            t = Thread(target = cancel, args = [1, con])
            t.start()
            cur.execute('select pg_sleep(5), version()')
            t.join()
            print(cur.fetchall())
        except Exception as e:
            import traceback
            traceback.print_exc()
EOF
python hoge.py
deactivate
docker stop postgres_$$

詳細

PostgreSQL14について

環境構築スクリプト内先頭で起動しています。

docker run -d --rm -e POSTGRES_PASSWORD=pass -v $(pwd)/data:/var/lib/postgresql/data -p 5432:5432 --name postgres_$$ postgres:14-alpine

環境構築スクリプト内最後で終了しています。

docker stop postgres_$$

PostgreSQLの公式docker image
https://hub.docker.com/_/postgres

venvについて

一度構築した後は、以下で環境に入れます

. env/bin/activate

抜けるには、以下。

deactivate

python公式のvenv
https://docs.python.org/ja/3/library/venv.html

psycog2を使ったキャンセル例

with使用、GUI排除、pg_sleepによるクエリ結果の遅延により確実な自動キャンセルとスリム化を図っていますが、大体同じです。
ただ本来の主な用途はCtrl+CによるSIGINT/TERMの処理、pythonだとKeyboardInterruptに当たるので、スレッドを作ることはあまりないかと思います。
hoge.py

import psycopg2
from threading import Thread
from time import sleep
def cancel(t, con):
    sleep(t)
    con.cancel()
with psycopg2.connect(
        host = "localhost",
        user = "postgres",
        password = "pass",
        dbname = "postgres"
    ) as con:
    with con.cursor() as cur:
        try:
            t = Thread(target = cancel, args = [1, con])
            t.start()
            cur.execute('select pg_sleep(5), version()')
            t.join()
            print(cur.fetchall())
        except Exception as e:
            import traceback
            traceback.print_exc()

psycopg2公式ドキュメント
https://www.psycopg.org/docs/

---

(追記)

環境構築後の環境で動作するtkinterキャンセル例

質問がいつまで経っても良くならないので、例だけつけておきました。
質問のコメント欄に書いたキューを使わず、スレッドのjoinをポーリングで待ち合わせる例です。
基本的にtkinterはtkをどこまで信用できるのか分からないので、アバウトな制御しかしていません。
ご参考までにｗ

import tkinter as tk
from tkinter import ttk
from time import sleep
from threading import Thread
import psycopg2

def query(obj):
    with psycopg2.connect(
            host = "localhost",
            user = "postgres",
            password = "pass",
            dbname = "postgres"
        ) as con:
        with con.cursor() as cur:
            try:
                obj['con'] = con
                cur.execute('select pg_sleep(10), version(), timeofday()')
                obj['con'] = None
                data = cur.fetchall()
                obj['result'] = data
            except Exception as e:
                import traceback
                traceback.print_exc()
    obj['con'] = None
    obj['finished'] = True

query_index = 1
def new_query_index():
    global query_index
    result = query_index
    query_index += 1
    return result

def add_list(queries, listbox, comp):
    number = new_query_index()
    key = f'query-{number}'
    listbox.insert(listbox.size(), key)
    obj = {'name' : key, 'number' : number, 'finished' : False, 'thread' : None, 'result' : None, 'con': None}
    t = Thread(target = query, args=[obj])
    obj['thread'] = t
    queries[key] = obj
    t.start()
    comp.pack()

def search_index_from_listbox(value, listbox):
    content = listbox.get(0, listbox.size())
    for i, name in enumerate(content):
        if name == value:
            return i
    return -1
    
def cancel(queries, listbox):
    tpl = listbox.curselection()
    for i in tpl:
        name = listbox.get(i)
        obj = queries[name]
        con = obj['con']
        if con and not obj['finished']:
            con.cancel()

def join_finished_threads(queries, listbox, comp):
    for k, v in list(queries.items()):
        if v['finished']:
            v['thread'].join()
            queries.pop(k)
            listbox.delete(search_index_from_listbox(v['name'], listbox))
            print(v['result'])
    comp.pack()

def main():
    queries = {}
    def polling():
        join_finished_threads(queries, listbox, frame)
        frame.after(100, polling)

    root = tk.Tk()
    root.geometry('220x300')
    root.title('スレッド終了のポーリング監視')
    frame = ttk.Frame(root, padding=10)
    listbox = tk.Listbox(frame, selectmode="multiple", height=10)
    listbox.grid(column=0, row=0, columnspan=2)
    frame.grid()
    button_add = ttk.Button(frame, text='追加', command=lambda: add_list(queries, listbox, frame)).grid(column=0, row=1)
    button_cancel = ttk.Button(frame, text='キャンセル', command=lambda: cancel(queries, listbox)).grid(column=1, row=1)
    frame.pack(padx=10, pady=20)
    polling()
    root.mainloop()

if __name__ == '__main__':
    main()

ついでにqueue版。別スレッドからbindを使うのは怖かったので(使えれば自前Queueも不要だし)、結局UIスレッドからポーリング。

import tkinter as tk
from tkinter import ttk
from time import sleep
from threading import Thread
import psycopg2
from queue import Queue

def query(obj, commands, queries, listbox, comp):
    with psycopg2.connect(
            host = "localhost",
            user = "postgres",
            password = "pass",
            dbname = "postgres"
        ) as con:
        with con.cursor() as cur:
            try:
                obj['con'] = con
                cur.execute('select pg_sleep(10), version(), timeofday()')
                obj['con'] = None
                data = cur.fetchall()
                obj['result'] = data
            except Exception as e:
                import traceback
                traceback.print_exc()
    obj['con'] = None
    obj['finished'] = True

    def query_on_ui_thread(obj, queries, listbox, comp):
        obj['thread'].join()
        listbox.delete(search_index_from_listbox(obj['name'], listbox))
        print(obj['result'])
        queries.pop(obj['name'])
        comp.pack()

    commands.put(lambda: query_on_ui_thread(obj, queries, listbox, comp))

query_index = 1
def new_query_index():
    global query_index
    result = query_index
    query_index += 1
    return result

def add_list(queries, listbox, comp, commands):
    number = new_query_index()
    key = f'query-{number}'
    listbox.insert(listbox.size(), key)
    obj = {'name' : key, 'number' : number, 'finished' : False, 'thread' : None, 'result' : None, 'con': None}
    t = Thread(target = query, args=[obj, commands, queries, listbox, comp])
    obj['thread'] = t
    queries[key] = obj
    t.start()
    comp.pack()

def search_index_from_listbox(value, listbox):
    content = listbox.get(0, listbox.size())
    for i, name in enumerate(content):
        if name == value:
            return i
    return -1
    
def cancel(queries, listbox):
    tpl = listbox.curselection()
    for i in tpl:
        name = listbox.get(i)
        obj = queries[name]
        con = obj['con']
        if con and not obj['finished']:
            con.cancel()

def main():
    queries = {}
    commands = Queue()
    def polling():
        while not commands.empty():
            commands.get()()
        frame.after(100, polling)

    root = tk.Tk()
    root.geometry('220x300')
    root.title('スレッド終了のポーリング監視')
    frame = ttk.Frame(root, padding=10)
    listbox = tk.Listbox(frame, selectmode="multiple", height=10)
    listbox.grid(column=0, row=0, columnspan=2)
    frame.grid()
    button_add = ttk.Button(frame, text='追加', command=lambda: add_list(queries, listbox, frame, commands)).grid(column=0, row=1)
    button_cancel = ttk.Button(frame, text='キャンセル', command=lambda: cancel(queries, listbox)).grid(column=1, row=1)
    frame.pack(padx=10, pady=20)
    polling()
    root.mainloop()

if __name__ == '__main__':
    main()

Comments

[person]

質問に対する回答付け足していただきありがとうございます。

実行しながら確認してみます。

[person]

query_on_ui_thread()で、join()してGUIを更新した後のcomp.pack()はなぜ入れているのでしょうか？

[dameo]

あまり深い意味はありません。
tkを信用してないので、UIいじったらウィジェットの形が変わる可能性を考慮して、こまめにpackしてるだけです。
質問だけはして、自分は依頼に応じないスタンスはどうかと思いますよ。
何を知りたいのか、詰まっている部分を明確にし、そこだけをピンポイントで聞いてください。
我々はあなたのメンターではありません。

[person]

すみません。
行き詰まる内容によっては、質問することで別の不明点がでてきたり、本来の質問とは関連性がない些細なことも気になってしまいます。何卒ご容赦ください。

あとtkって信用できないのですか？

[dameo]

容赦できるレベルじゃないので注意しています。
私は信用していませんね。
1つ1つ別の質問としてあげてください。

[person]

回答上の環境構築の辺は知識無いのでよくわかりませんが、
その下のtkinterの実装のスレッド間の処理の流れは理解しました。

画面遷移絡みのGUIになるので、そのままは使えませんが、そういった実装ができるかどうかの確認も含めて参考にさせていただきます。

[dameo]

回答ではないただの参考情報なので、teamiklさんの有益な回答をベストアンサーにしてください。
コメントのQueue2つの話はやや冗長な気がしなくもないし、セオリーという感じでもないですが、マルチスレッドに対する手堅い姿勢は評価に値します。