1. 在主进程下开启线程

1

2

3

4

5

6

7

8

9

from threading import Thread

def work():

    print("hello")

if __name__ == '__main__':

    t = Thread(target=work)

    t.start()

    print("主线程/主进程")

　　执行结果如下：几乎是t.start()的同时就将线程开启了，然后先打印出了hello，证明线程的创建开销极小

1

2

hello

主线程/主进程

2、在主进程下开启子进程

1

2

3

4

5

6

7

8

9

10

11

from multiprocessing import Process

def work():

    print('hello')

if __name__ == '__main__':

    # 在主进程下开启子进程

    p = Process(target=work)

    p.start()

    print('主线程/主进程')

　　执行结果如下：p.start()将开启进程的信号发给操作系统后，操作系统要申请内存空间，让好拷贝父进程地址空间到子进程，开销远大于线程

1

2

主线程/主进程

hello

1

2

3

4

5

6

7

8

9

10

11

12

13

from threading import Thread

import os

def work():

    print('hello', os.getpid())

if __name__ == '__main__':

    p1 = Thread(target=work)

    p2 = Thread(target=work)

    p1.start()

    p2.start()

    print('主线程/主进程', os.getpid())

执行结果

1

2

3

hello 28818

主线程/主进程 28818

hello 28818

1

2

3

4

5

6

7

8

9

10

11

12

13

from multiprocessing import Process

import os

def work():

    print('hello', os.getpid())

if __name__ == '__main__':

    p1 = Process(target=work)

    p2 = Process(target=work)

    p1.start()

    p2.start()

    print('主线程/主进程', os.getpid())

　　执行结果

1

2

3

主线程/主进程 28932

hello 28933

hello 28934

1

2

3

4

5

6

7

8

9

10

11

12

13

14

from multiprocessing import Process

import os

def work():

    global n

    n = 0

if __name__ == '__main__':

    n = 100

    p = Process(target=work)

    p.start()

    p.join()

    print('主', n)

　　执行结果如下：毫无疑问子进程p已经将自己的全局的n改成了0，但改的仅仅是它自己的，查看父进程的n仍然为100

1

主 100

1

2

3

4

5

6

7

8

9

10

11

12

13

14

from threading import Thread

import os

def work():

    global n

    n = 0

if __name__ == '__main__':

    n = 100

    t = Thread(target=work)

    t.start()

    t.join()

    print('主', n)

　　执行结果如下：查看结果为0，因为同一进程内的线程之间共享进程内的数据

1

主 0