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　

巴特西

python第九天（9-33）

一：进程

二：线程

最新文章

热门文章