并发编程 - 线程 - 1.开启线程的两种方式/2.进程与线程的区别/3.Thread对象的其他属性或方法/4.守护线程

1.开启线程的两种方式：
　　进程，线程：
   　　 进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合）而线程才是cpu上的执行单位）
   　　 1.同一个进程内的多个线程共享该进程内的地址资源
    　　2.创建线程的开销远小于创建进程的开销（创建一个进程，就是创建一个车间，涉及到申请空间，
      　　而且在该空间内建至少一条流水线，但创建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小）

 # 方式1：
 from threading import Thread
 import time

 def sayhi(name):
     time.sleep(2)
     print('%s say hello'%name)

 if __name__ == "__main__":
     t=Thread(target=sayhi,args=('alice',))
     t.start()
     print('主线程')  # 一个进程，一个主线程，开启了一个线程

 # 方式2：
 from threading import Thread
 import time

 class Sayhi(Thread):
     def __init__(self,name):
         super().__init__()
         self.name = name

     def run(self):
         time.sleep(2)
         print('%s say hello'%self.name)

 if __name__ == "__main__":
     t = Sayhi('alice')
     t.start()
     print('主线程')

2.进程与线程的区别：
　　1.开进程的开销远大于开线程
　　2.同一进程内的多个线程共享该进程的地址空间
　　3.瞅一眼pid

 # 1.
 import time
 from threading import Thread
 from multiprocessing import Process

 def piao(name):
     print('%s piaoing' %name)
     time.sleep(2)
     print('%s piao end' %name)

 if __name__ == '__main__':
     # p1=Process(target=piao,args=('egon',))
     # p1.start() # 发出去后，没有立刻反应 开进程开销大

     t1=Thread(target=piao,args=('egon',))
     t1.start()  # 发出去后，立刻就反应了，开线程开销小

     print('主线程')
 """
 主线程
 egon piaoing
 egon piao end
 """
 """
 egon piaoing
 主线程
 egon piao end
 """
 # 2.
 from threading import Thread
 from multiprocessing import Process

 n=100
 def task():
     global n
     n=0

 if __name__ == '__main__':
     # p1=Process(target=task)
     # p1.start()
     # p1.join() # 彼此隔离的 n = 100

     t1=Thread(target=task)
     t1.start()
     t1.join()  # 共享地址空间 n = 0

     print('主线程',n)
 """
 主线程 100
 """
 """
 主线程 0
 """
 # 3.
 from threading import Thread
 from multiprocessing import Process,current_process
 import os

 def task():
    print(current_process().pid)
    print(os.getpid(),os.getppid())

 if __name__ == '__main__':
     # p1=Process(target=task)
     # p1.start()  # pid 不一样
     # p1.join()

     t1=Thread(target=task)
     t1.start()  # 线程pid 一样
     t1.join()

     print('主线程',current_process().pid)
     print('主线程',os.getpid(),os.getppid())
 """
 38780
 38780 43168
 主线程 43168
 主线程 43168 12480
 """
 """
 58912
 58912 12480
 主线程 58912
 主线程 58912 12480
 """

3.Thread对象的其他属性或方法：
　　currentThread().getName()
　　t.setName()
　　t.is_alive()
　　t.isAlive()
　　t.join()
　　active_count()
　　enumerate()

 from threading import Thread,currentThread,active_count,enumerate
 import time

 def task():
     print('%s is running'%currentThread().getName())
     time.sleep(2)
     print('%s is done'%currentThread().getName())

 if __name__ == "__main__":
     t = Thread(target=task,name='子线程1')
     t.start()
     # t.join()
     # print(t.getName())
     # t.setName('儿子线程1')
     # currentThread().setName('主进程')
     # print(t.is_alive())
     # print(t.isAlive())
     # print('主线程：',currentThread().getName())
     t.join()
     # print(active_count())  # 2 没有join 1 有join
     print(enumerate())  # [<_MainThread(MainThread, started 41144)>]

 """
 Thread-1 is running
 Thread-1
 主线程 MainThread
 Thread-1 is done
 """
 """
 子线程1 is running
 子线程1
 主线程 MainThread
 子线程1 is done
 """
 """
 子线程1 is running
 主线程 MainThread
 儿子线程1 is done
 """
 """
 子线程1 is running
 主线程： 主进程
 子线程1 is done
 """
 """
 子线程1 is running
 子线程1 is done
 False
 False
 主线程： MainThread
 """

4.守护线程：
　　一个进程什么时候被销毁，
    1.不开线程，代码完毕，该进程就被销毁
    2.主线程等到所有子线程死了后，他才死
        守护线程等到所有的子线程死了后，他才死

 from threading import Thread
 import time

 def sayhi(name):
     time.sleep(2)
     print('%s say hello' %name)

 if __name__ == '__main__':
     t=Thread(target=sayhi,args=('egon',))
     # t.setDaemon(True) #必须在t.start()之前设置
     t.daemon=True
     t.start()

     print('主线程')
     print(t.is_alive())  # t 跟着死了 一个线程内没有开启非守护线程
 """
 主线程
 True
 """

 from threading import Thread
 import time

 def foo():
     print(123)
     time.sleep(4)
     print("end123")

 def bar():
     print(456)
     time.sleep(3)
     print("end456")

 if __name__ == '__main__':
     t1=Thread(target=foo)
     t2=Thread(target=bar)

     t1.daemon=True
     t1.start()
     t2.start()
     print("main-------")
 """
 123    foo time.sleep(1)
 456
 main-------
 end123
 end456
 """
 """
 123     foo time.sleep(4)
 456
 main-------
 end456
 """