python第九天（9-33）

　　

一：进程

• 进程概念
  • 进程就是一个程序运行在一个数据集上的一次动态执行过程
  • 进程一般由程序，数据集，进程控制块组成
  • 进程控制块： 进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志（通俗讲就是记录进程状态信息）

二：线程

• 线程概念
  • 一个程序至少有一个进程，一个进程至少有一个线程
  • 线程是进程的组成部分，线程是最小的执行单位
  • 进程相当于一个容器，是最小的资源单位
  • 线程共用进程的资源，线程是进程中的一个实体
  • 一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成
  • 一个线程可以创建和撤消另一个线程

一：线程的创建与调用（threading中Thread类）

• 创建一个主线程的子线程对象
  • t1=threading.Thread(target=read)
  • target:指向函数,arg：传递函数参数
• 启用一个子线程
  • t1.start()
  • 实际start()只是让线程处于就绪态，开始一个线程时run()方法实现的　　

 1 import threading
 2 import time
 3 def read():
 4     print("I am reading at %s"%time.ctime())
 5     time.sleep(3)
 6     print("i am finish reading at %s"%time.ctime())
 7 def music():
 8     print("i am listening music at %s"%time.ctime())
 9     time.sleep(3)
10     print("i am finish listening music at %s"%time.ctime())
11 if __name__=="__main__":
12     t1=threading.Thread(target=read)#创建这个程序的主线程的子线程对象
13     #target:指向调用的函数，arg用于传递函数中的参数
14     t1.start()#启用某个线程
15     t2=threading.Thread(target=music)
16     t2.start()

线程执行的理解

1.首先t1,t2与主线程开启，直接输出
I am reading at Thu Jan 31 12:20:38 2019
I am listening music at Thu Jan 31 12:20:38 2019
Main threading ending at Thu Jan 31 12:20:38 2019...

2.俩个进程等待三秒钟
3.最后输出
I am finish listening music at Thu Jan 31 12:20:41 2019
I am finish reading at Thu Jan 31 12:20:41 2019

二：join的用法理解

 1 import threading
 2 import time
 3 def read():
 4     print("I am reading at %s"%time.ctime(),end="\n")
 5     time.sleep(3)
 6     print("I am finish reading at %s"%time.ctime(),end="\n")
 7 def music():
 8     print("I am listening music at %s"%time.ctime())
 9     time.sleep(5)
10     print("I am finish listening music at %s"%time.ctime(),end="\n")
11 if __name__=="__main__":
12     t1=threading.Thread(target=read)#创建这个程序的主线程的子线程对象
13     #target:指向调用的函数，arg用于传递函数中的参数
14     t2=threading.Thread(target=music)
15     t1.start()  # 启用某个线程
16     t2.start()
17     #t1.join()
18     t2.join()
19     print(r"main threading ending at %s..."%time.ctime())

join用法的理解

• 没有join时，主线程开子线程一起执行

• 注释掉t2.join()　　　　　　　　　　

• • • 1.执行t1,t2子线程
          I am reading at Thu Jan 31 13:09:39 2019
          I am listening music at Thu Jan 31 13:09:39 2019
      2.进入等待3秒钟
      3.执行t1子线程和主线程
          I am finish reading at Thu Jan 31 13:09:42 2019
      　　main threading ending at Thu Jan 31 13:09:44 2019...
      4.进入等待俩秒钟
      5。执行t2
          I am finish listening music at Thu Jan 31 13:09:44 2019

• 注释掉t1.join

  • • 1.执行t1,t2子线程
              I am reading at Thu Jan 31 13:20:50 2019
              I am listening music at Thu Jan 31 13:20:50 2019
      2.进入等待5秒钟，单线程1只需等待三秒钟，所以在三秒钟时会继续执行ti线程
              I am finish reading at Thu Jan 31 13:20:53 2019
      3.在三秒钟后在过俩秒钟执行t2和主线程
              I am finish listening music at Thu Jan 31 13:23:28 2019
              main threading ending at Thu Jan 31 13:23:28 2019...    　　　　　　

• 都不注释

  • • 1.执行t1,t2子线程
          I am reading at Thu Jan 31 13:26:55 2019
          I am listening music at Thu Jan 31 13:26:55 2019
      2，进入等待5秒，在第三秒执行t1
          I am finish reading at Thu Jan 31 13:26:58 2019
      3.再过俩秒执行t2和主线程
          I am finish listening music at Thu Jan 31 13:27:00 2019
          main threading ending at Thu Jan 31 13:27:00 2019...
          

三：总结

　　在没有join时，主线程会与子线程同时执行，但当子线程有了设置了join时，主线程会等待带有join的子线程执行完毕再结束，如果一个进程的join设置再另一个线程开始之前，后者会在前者执行完毕再执行，如果是x.start+x.join+x1.start+x1.join。。。这种格式就成了穿行

• 守护线程的概念

  • 只要主线程完成了，不管守护子线程是否完成，都要和主线程一起退出，整个Python会在所有的非守护线程结束后才会结束，即进程中没有非守护线程存在的时候才结束

• setDaemon方法实例理解

 import threading
 import time
 def read():
     print("I am reading at %s"%time.ctime(),end="\n")
     time.sleep()
     print("I am finish reading at %s"%time.ctime(),end="\n")
 def music():
     print("I am listening music at %s"%time.ctime())
     time.sleep()
     print("I am finish listening music at %s"%time.ctime(),end="\n")
 if __name__=="__main__":
     t1=threading.Thread(target=read)
     t2=threading.Thread(target=music)
     t1.setDaemon(True)
     t1.start()
     t2.start()
     print(r"main threading ending at %s..."%time.ctime())

一.设置t1为守护线程是看不到效果的，因为，主进程在所有非守护线程结束了才会结束
二：设置t2为守护线程
    1.首先执行t1,t2和主线程
       执行结果：
            I am reading at Fri Feb  1 20:28:58 2019
            I am listening music at Fri Feb  1 20:28:58 2019
            main threading ending at Fri Feb  1 20:28:58 2019...

    2.由于主线程会在所有非守护线程结束后才结束，所以非守护线程t1在3秒后结束，从而主线程结束，t2被迫
        结束
        执行结果：
            I am finish reading at Fri Feb  1 20:29:01 2019
            Process finished with exit code 0

# run():  线程被cpu调度后自动执行线程对象的run方法
# start():启动线程活动。
# isAlive(): 返回线程是否活动的。
# getName(): 返回线程名。
# setName(): 设置线程名。

threading模块提供的一些方法：
# threading.currentThread(): 返回当前的线程变量。
　　　　　　#<_MainThread(MainThread, started 14428)>#输出的主线程名字MainThread
# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
　　　　　　#[<_MainThread(MainThread, started 13548)>, <Thread(Thread-1, started 10348)>, <Thread(Thread-2, started 18144)>]
　　　　　　#从这里可以发现主线程实在所有线程结束后才结束
# threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

最后补充一下线程的类调用方法　https://www.cnblogs.com/yuanchenqi/articles/6248025.html