# #守护进程

from multiprocessing import Process

import os,time,random

def task():

    print('%s is running' %os.getpid())

    time.sleep(2)

    print('%s is done' %os.getpid())

    # p = Process(target=time.sleep, args=(3,))

    # p.start()

if __name__ == '__main__':

    p=Process(target=task)

    p.daemon = True #1、必须在p.start()之前 2：守护进程不能开启子进程

    p.start()

    # p.join()

    print('主')

#

#     '''

#     举例说明守护进程的应用场景：

#         假设有两个任务要干，要玩出并发的效果，使用进程的话可以让主进程

#         执行一个任务，然后开启一个子进程执行一个任务。

#

#         如果这两个任务毫无关系，那么就像上面这么做就可以

#         如果主进程的任务在执行完毕后，子进程的任务没有存在的意义了

#         那么该子进程应该在开启之前就被设置成守护进程

#     '''

#主进程代码运行完毕,守护进程就会结束

from multiprocessing import Process

from threading import Thread

import time

def foo():

    print('start 123')

    time.sleep(1)

    print('end 123')

def bar():

    print('start 456')

    time.sleep(1)

    print('end 456')

if __name__ == '__main__':

    p1 = Process(target=foo)

    p2 = Process(target=bar)

    p1.daemon = True

    p1.start()

    p2.start()

    print('main----------')

# main----------

# start 456

# end 456

#打印该行则主进程代码结束,则守护进程p1应该被终止,

# 可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

from threading import Thread

import time,os

def run():

    print('%s is running '%os.getpid())

    time.sleep(2)

    print('%s is done ' %os.getpid())

if __name__ == '__main__':

    t = Thread(target=run)

    t.daemon = True

    t.start()

    print('主')

# 11004 is running

# 主

from threading import Thread

import time

def foo():

    print('start 123')

    time.sleep(1)

    print('end 123')

def bar():

    print('start 456')

    time.sleep(1)

    print('end 456')

if __name__ == '__main__':

    p1 = Thread(target=foo)

    p2 = Thread(target=bar)

    p1.daemon = True

    p1.start()

    p2.start()

    print('main----------')

# start 123

# start 456

# main----------

# end 123

# end 456