1
import multiprocessing
2

3

4
def worker(n):
5
    """子进程要执行的任务"""
6
    print(f'子进程 {n}  正在执行')
7

8

9
def main():
10
    task_lists = []
11
    for i in range(100)
12
        # 创建一个进程对象
13
        p = multiprocessing.Process(target=worker, args=(i,))
14

15
        # 启动进程
16
        p.start()
17

18
        # 将子进程添加到进程列表里
19
        task_lists.append(p)
20

21
    for p in task_lists:
22
        # 等待子进程结束
23
        p.join()
24

25
    print('主进程结束')
26

27

28
if __name__ == '__main__':
29
    main()

1
import multiprocessing
2

3
class MyProcess(multiprocessing.Process):
4
    def __init__(self, arg1, arg2):
5
        super(MyProcess, self).__init__()  # 调用父类的初始化方法
6
        self.arg1 = arg1
7
        self.arg2 = arg2
8

9
    def run(self):
10
        """重载父类中的run方法，实现进程执行的逻辑"""
11
        print('子进程启动')
12
        # 实现进程的逻辑代码
13

14
if __name__ == '__main__':
15
    p = MyProcess(arg1_value, arg2_value)  # 创建进程对象
16
    p.start()  # 启动子进程
17
    p.join()  # 等待子进程结束
18
    print('主进程结束')

1
import threading
2

3

4
# 定义线程执行的任务函数
5
def task(n):
6
    # 线程要执行的代码
7
    print(n)
8
    pass
9

10

11
def main(num_threads):
12
    threads = []
13

14
    for i in range(num_threads):
15
        # 创建线程对象
16
        t = threading.Thread(target=task, args=(i,))
17
        threads.append(t)
18

19
        # 启动线程
20
        t.start()
21

22
    # 等待所有线程执行完毕
23
    for t in threads:
24
        # 主线程等待子线程执行完毕
25
        t.join()
26

27

28
if __name__ == '__main__':
29
    main(100)

1
import threading
2

3

4
# 自定义一个继承自Thread类的子类
5
class MyThread(threading.Thread):
6
    def __init__(self, threadID, name, counter):
7
        threading.Thread.__init__(self)
8
        self.threadID = threadID
9
        self.name = name
10
        self.counter = counter
11

12
    # 重写run方法，即线程启动后执行的方法
13
    def run(self):
14
        print("Starting " + self.name)
15
        # 使用锁机制保证数据同步
16
        threadLock.acquire()
17
        print_time(self.name, self.counter, 3)
18
        threadLock.release()
19

20

21
def print_time(threadName, delay, counter):
22
    while counter:
23
        time.sleep(delay)
24
        print(f"{threadName}: {time.ctime(time.time())}")
25
        counter -= 1
26

27

28
def main():
29
    # 创建锁实例
30
    threadLock = threading.Lock()
31

32
    # 创建两个线程
33
    thread1 = MyThread(1, "Thread-1", 1)
34
    thread2 = MyThread(2, "Thread-2", 2)
35

36
    # 启动线程
37
    thread1.start()
38
    thread2.start()
39

40
    # 等待线程完成
41
    thread1.join()
42
    thread2.join()
43

44
    print("Exiting Main Thread")
45

46

47
if __name__ == '__main__':
48
    main()

1
import time
2
import threading
3

4
# 守护进程函数
5
def daemon():
6
    print("Daemon started")
7
    while True:
8
        time.sleep(1)
9
        print("Daemon is still running")
10

11
# 主程序
12
if __name__ == '__main__':
13
    t = threading.Thread(target=daemon)
14
    t.daemon = True   # 将线程设置为守护进程
15
    t.start()
16

17
    time.sleep(5)   # 主线程等待5秒后结束
18
    print("Main thread exit.")

1
import threading
2
import time
3

4
def daemon_func():
5
    while True:
6
        print("Daemon thread is running...")
7
        time.sleep(1)
8

9
if __name__ == "__main__":
10
    daemon_thread = threading.Thread(target=daemon_func)
11
    daemon_thread.setDaemon(True)  # 设置为守护线程
12
    daemon_thread.start()
13

14
    # 主线程休眠5秒
15
    time.sleep(5)
16

17
    print("Main thread is exiting...")