线程，进程，GIL，join，Daemon，threading.current_thread()，threading.active_count()

线程，进程，GIL，join，Daemon，threading.current_thread()，threading.active_count()
    1.线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。
          一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执
          行不同的任务。
        一个线程就是一个指令集和
        例：
        #author: wylkjj
        #date:2019/4/21
        import time
        import threading #创建线程所需要调用的模块

        begin=time.time()
        def foo(n):
            print('foo%s'%n)
            time.sleep(1)#sleep状态不占cpu，也就是cpu不工作
            print('end foo')
        def bar(n):
            print('bar%s'%n)
            time.sleep(2)
            print('end bar')
        # foo()
        # bar()
        t1=threading.Thread(target=foo,args=(1,))
        t2=threading.Thread(target=bar,args=(2,))
        #注：t1，t2，还有原进程同时进行，不分先后（抢占cpu资源）
        print('......in the main......')

        t1.start()#执行子进程
        t2.start()#执行子进程
        end=time.time()
        print(end-begin)#程序运行时间：0.0009768009185791016
        t1.join()#卡住进程
        t2.join()#卡住进程
        end=time.time()
        print(end-begin)#卡住进程后的程序运行时间：2.001460075378418
        #注：并行：并行是同时进行，真正意义上的两件事情同时干
        #         多核，当一核运行一个程序，两个程序两核同时运行就是并行
        #    并发：并发并不是同时进行
    注：
        #多线程：IO密集型任务或函数（有阻塞情况的，例如：time.sleep（））
        #计算密集型任务函数不适合多线程
        import time
        import threading
        begin=time.time()
        def add(n):
            sum=0
            for i in range(n):
                sum+=1
            print(sum)
        #串行
        # add(10000000)
        # add(20000000)
        # end=time.time()
        # print(end-begin)#运行时间：1.6457252502441406
        #并发：此并发无阻塞所以要保存切换时的状态，切换会消耗大量时间（一核cpu下并发，多核就可以并行）
        t1=threading.Thread(target=add,args=(10000000,))
        t2=threading.Thread(target=add,args=(20000000,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        #join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一
        #直等待其他的子线程执行结束之后，主线程在终止，否则主线程会杀死子线程
        #主线程结束后子线程无论是否执行完毕都将结束，因此join的作用就显现出来了
        end=time.time()
        print(end-begin)#运行时间：1.6939148902893066
    2.进程：是一堆资源的整合，一个程序的执行实例（注：进程不可以资源共享，但线程可以资源共享）
            注：线程和进程一样块（线程在执行时，等于进程，同一个体系）注：进程开销大
    3.GIL(global interpreter lock)解释器上的一个bug，只有cpython解释器有这个问题，因为cpython里面加了一把锁GIL
      GIL：在同一时刻只能有一个线程进入解释器（历史问题）
    4.python里面因为GIL锁所以一个进程无法多线程，所以只能用多进程去实现多线程（可行但不完美）
结论：在python里：
      if任务是IO密集型的 可以用多线程
      面对计算密集型，改cpython或用其它解决办法
      （1）进程是相互独立互不影响的，但线程中主线程会影响子线程
      （2）无论什么情况进程中同一时刻只能有一个线程运行，如果想
           运用多核就要创建多进程
    5.join():阻塞作用
             join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，
             一直等待其他的子线程执行结束之后，主线程在终止
    join有一个timeout参数：
        (1).当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序。所以说，如果有10个子
            线程，全部的等待时间就是每个timeout的累加和。简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，
            不管任务有没有完成，直接杀死。
        (2).没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，
            子线程依然可以继续执行，直到子线程全部结束，程序退出。
    6.Daemon：（守护线程，守护进程）
    在脚本运行过程中有一个主线程，若在主线程中创建了子线程，当主线程结束时根据子线程daemon属性值的不同可能会发生下面的两种情
    况之一。

    （1）如果某个子线程的daemon属性为False，主线程结束时会检测该子线程是否结束，如果该子线程还在运行，则主线程会等待它完成后
         再退出；
    （2）如果某个子线程的daemon属性为True，主线程运行结束时不对这个子线程进行检查而直接退出，同时所有daemon值为True的子线程
         将随主线程一起结束，而不论是否运行完成。

    属性daemon的值默认为False，如果需要修改，必须在调用start()方法启动线程之前进行设置。另外要注意的是，上面的描述并不适用于
    IDLE环境中的交互模式或脚本运行模式，因为在该环境中的主线程只有在退出Python IDLE时才终止。
    7.threading.current_thread():print(threading.current_thread())查看线程情况，分级出子线程和主线程，当前执行的线程是哪个
    8.threading.active_count()：print(threading.active_count())：查看进程中还有几个线程在运行（未jion的）
（7、8）实例：
    import time
    import threading #创建线程所需要调用的模块

    begin=time.time()
    def foo(n):
        print(threading.current_thread())
        print('foo%s'%n)
        time.sleep(1)#sleep状态不占cpu，也就是cpu不工作
        print('end foo')
    def bar(n):
        print(threading.current_thread())
        print('bar%s'%n)
        time.sleep(2)
        print('end bar')
    # foo()
    # bar()
    t1=threading.Thread(target=foo,args=(1,))
    t2=threading.Thread(target=bar,args=(2,))
    #注：t1，t2，还有原进程同时进行，不分先后（抢占cpu资源）
    print('......in the main......')

    t1.start()#执行子进程
    t2.start()#执行子进程

    end=time.time()
    print(end-begin)#程序运行时间：0.0009768009185791016

    # t1.join()#卡住进程
    # t2.join()#卡住进程
    end=time.time()
    print(threading.current_thread())
    print(threading.active_count())#进行中的进程（加jion给两个子线程就只有1个主线程在运行，不加join给两个子线程就有3个运行数）
    print(end-begin)#卡住进程后的程序运行时间：2.001460075378418