Python GUI多处理并且仍然冻结

Question

I'm using TKinter to draw a GUI for a python program im making, and I have it updating at about 200ms, but when the program queries the data it locks the program because it takes a second to get the data. I tried to write it into multi processing so each query would be its own process and just share the info with global variables because my program is a real time program that uses wmi to get performance data. At least thats what I have so far. Not the end goal just the start. So if you could help me figure out why even with multiprocessing if it queries the info while I'm dragging the app across the screen it will freeze for a second.

import wmi
import time
import Tkinter as tk
from multiprocessing import cpu_count
import Image
from PIL import ImageTk
from Tkinter import Button, Label
import threading
from multiprocessing import Process, Value, Array

window = Tk();
global pct_in_use
global available_mbytes
global utilization
global hours_up
a= 0 
b=0    


def build_labels(gui, string):
    var = StringVar()
    label = Label( gui, textvariable=var, relief=RAISED )
    var.set(string)
    return label

def get_uptime():
    global hours_up
    c = wmi.WMI()
    secs_up = int([uptime.SystemUpTime for uptime in c.Win32_PerfFormattedData_PerfOS_System()][0])
    hours_up = secs_up / 3600
    return hours_up

def get_cpu():
    global utilization
    c = wmi.WMI()
    utilizations = [cpu.LoadPercentage for cpu in c.Win32_Processor()]
    utilization = int(sum(utilizations) / len(utilizations))  # avg all cores/processors
    return utilization

def get_mem_mbytes():
    global available_mbytes
    c = wmi.WMI()
    available_mbytes = int([mem.AvailableMBytes for mem in c.Win32_PerfFormattedData_PerfOS_Memory()][0])
    return available_mbytes

def get_mem_pct():
    global pct_in_use
    c = wmi.WMI()
    pct_in_use = int([mem.PercentCommittedBytesInUse for mem in c.Win32_PerfFormattedData_PerfOS_Memory()][0])
    return pct_in_use

def Draw():
    global mem_per_lb
    global cpu_lb
    global up_time_lb
    global mb_used_lb

    mem_pct = 0
    mem_per_lb = tk.Label(text='Memory % ' + str(mem_pct))
    mem_per_lb.place(x=10, y=10)

    cpu = 0
    cpu_lb = tk.Label(text='CPU % ' + str(cpu))
    cpu_lb.place(x=10, y=30)

    mem_pct = 0
    up_time_lb = tk.Label(text='UP Time % ' + str(mem_pct))
    up_time_lb.place(x=10, y=50)

    mem_pct = 0
    mb_used_lb = tk.Label(text='Memory MB ' + str(mem_pct))
    mb_used_lb.place(x=10, y=70)    


def Refresher():
    global mem_per_lb
    global cpu_lb
    global up_time_lb
    global mb_used_lb

    mem_pct = get_mem_pct()
    cpu = get_cpu()
    up_time = get_uptime()
    mbused = get_mem_mbytes()

    window.wm_title('Vision' + time.asctime())
    mem_per_lb.configure(text='Memory % ' + str(pct_in_use))
    cpu_lb.configure(text='CPU ' + str(utilization))
    up_time_lb.configure(text='UP Time ' + str(hours_up))
    mb_used_lb.configure(text='Memory MB ' + str(available_mbytes))

    window.after(200, Refresher) # every second...

def draw_window():               #creates a window 
    window.geometry('704x528+100+100')

    image = Image.open('bg.jpg')     #gets image (also changes image size)
    image = image.resize((704, 528))
    imageFinal = ImageTk.PhotoImage(image)
    label = Label(window, image = imageFinal)   #creates label for image on window 
    label.pack()
    label.place(x = a, y = b)      #sets location of label/image using variables 'a' and 'b'

    Draw()
    Refresher()
    window.mainloop()

up_time_p = Process(target=get_uptime())
cpu_p = Process(target=get_cpu())
mb_p = Process(target=get_mem_mbytes())
pct_p = Process(target=get_mem_pct())
win_p = Process(target=draw_window())

up_time_p.start()
mb_p.start()
pct_p.start()
cpu_p.start()
win_p.start()

Answer 1

up_time_p = Process(target=get_uptime())
cpu_p = Process(target=get_cpu())
mb_p = Process(target=get_mem_mbytes())
pct_p = Process(target=get_mem_pct())
win_p = Process(target=draw_window())

I don't think you're supposed to include parentheses when you supply targets to a process. If you do that, the functions will execute in the main thread, and whatever those functions return will become the target.

up_time_p = Process(target=get_uptime)
cpu_p = Process(target=get_cpu)
mb_p = Process(target=get_mem_mbytes)
pct_p = Process(target=get_mem_pct)
win_p = Process(target=draw_window)

Answer 2

As per Kevin's answer, you're calling the functions when you create each process instance. So they are all actually running in the main process.

However, once you fix that problem your 'global' variables aren't going to work as you expect. When a process is created it takes a COPY of the parent processes memory. Any changes to that memory are not shared between the processes.

To achieve the result you want you'll have to use Python's threading library. Not the multiprocess library.

Threads share the same memory space as the parent process. Which can lead to its own problems. Though in your case the global variables you're changing are just integer constants so it should be okay.

from threading import Thread

data_funcs = (
    get_uptime, 
    get_cpu, 
    get_mem_mbytes, 
    get_mem_pct, 
    draw_window
)

threads = [Thread(target=f) for f in data_funcs]

for t in threads:
    t.start()

Is the general pattern you should use. You'll then have to figure out a way of killing those threads when you shut down the main process or it will hang.