python之线程

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import threading
import time


class MyThread(threading.Thread):
    def __init__(self, id):
        threading.Thread.__init__(self)
        self.id = id

    def run(self):
        x = 0
        time.sleep(10)
        print(self.id)
        print('线程结束：' + str(time.time()))


if __name__ == "__main__":
    t1 = MyThread(999)
    print('线程开始：' + str(time.time()))
    t1.start()
    t1.join()# 加上 这个就会单线执行  执行完了子线程 在执行主线程    不加子线程 和主线程同事执行
    print('主线程打印开始：' + str(time.time()))
    for i in range(5):
        print(i)
    time.sleep(2)
    print('主线程打印结束：' + str(time.time()))

运行结果： （have join（)）

线程开始：1555399104.58
999
线程结束：1555399114.58
主线程打印开始：1555399114.58
0
1
2
3
4
主线程打印结束：1555399116.58

运行结果:(no join())

线程开始：1555399270.59
主线程打印开始：1555399270.59
0
1
2
3
4
主线程打印结束：1555399272.59
999
线程结束：1555399280.59

'''
setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon()，
这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，
就不管子线程B是否完成，一并和主线程A退出.这就是setDaemon方法的含义，
这基本和join是相反的。此外，还有个要特别注意的：必须在start() 方法调用之前设置。
'''

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import threading
import time


class MyThread(threading.Thread):
    def __init__(self, id):
        threading.Thread.__init__(self)
        self.id = id

    def run(self):
        x = 0
        time.sleep(10)
        print(self.id)
        print("This is：" + self.getName())  # 获取线程名称
        print('线程结束：' + str(time.time()))


if __name__ == "__main__":
    t1 = MyThread(999)
    print('线程开始：' + str(time.time()))
    t1.setDaemon(True)
    t1.start()
    print('主线程打印开始：' + str(time.time()))
    for i in range(5):
        print(i)
    time.sleep(2)
    print('主线程打印结束：' + str(time.time())) 

运行结果：

线程开始：1555401428.69
主线程打印开始：1555401428.69
0
1
2
3
4
主线程打印结束：1555401430.69

*****************线程池的使用***********************

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#    需要安装  pip install futures
from concurrent.futures import ThreadPoolExecutor
import time                     # 参数times用来模拟网络请求的时间

def get_html(times):
    time.sleep(times)
    print("get page {}s finished".format(times))
    return times

executor = ThreadPoolExecutor(max_workers=2)
# 通过submit函数提交执行的函数到线程池中，submit函数立即返回，不阻塞
task1 = executor.submit(get_html, (3))
task2 = executor.submit(get_html, (2))
# done方法用于判定某个任务是否完成
print(task1.done())
# cancel方法用于取消某个任务,该任务没有放入线程池中才能取消成功
print(task2.cancel())
time.sleep(4)
print(task1.done())
# result方法可以获取task的执行结果
print(task1.result())

运行结果：
False
False
get page 2s finished
get page 3s finished
True
3

******************线程池的另一种实现方法*************************

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 
# 
''' map

除了as_completed方法，还可以使用executor.map方法，但是有一点不同。



使用map方法，无需提前使用submit方法，map方法与python标准库中的map含义相同，
都是将序列中的每个元素都执行同一个函数。上面的代码就是对urls的每个元素都执行get_html函数，
并分配各线程池。可以看到执行结果与上面的as_completed方法的结果不同，
输出顺序和urls列表的顺序相同，就算2s的任务先执行完成，也会先打印出3s的任务先完成，
再打印2s的任务完成。


'''

from concurrent.futures import ThreadPoolExecutor
import time
# 参数times用来模拟网络请求的时间
def get_html(times):
    time.sleep(times)
    print("get page {}s finished".format(times))
    return times

executor = ThreadPoolExecutor(max_workers=2)
urls = [3, 2, 4]
    # 并不是真的url
for data in executor.map(get_html, urls):
    print("in main: get page {}s success".format(data))

'''
运行结果：
get page 2s finished
get page 3s finished
in main: get page 3s success
in main: get page 2s success
get page 4s finished
in main: get page 4s success
'''

***************   线程 wait 方法*******************

'''
   wait   wait方法可以让主线程阻塞，直到满足设定的要求。

wait方法接收3个参数，等待的任务序列、超时时间以及等待条件。
等待条件return_when默认为ALL_COMPLETED，表明要等待所有的任务都结束。
可以看到运行结果中，确实是所有任务都完成了，主线程才打印出main。
等待条件还可以设置为FIRST_COMPLETED，表示第一个任务完成就停止等待。

'''

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED, FIRST_COMPLETED
import time
# 参数times用来模拟网络请求的时间
def get_html(times):
    time.sleep(times)
    print("get page {}s finished".format(times))
    return times

executor = ThreadPoolExecutor(max_workers=2)
urls = [3, 2, 4]
# 并不是真的url
all_task = [executor.submit(get_html, (url)) for url in urls]
wait(all_task, return_when=ALL_COMPLETED)
print("main")

运行结果：
get page 2s finished
get page 3s finished
get page 4s finished
main

*************************线程通信例程*******************************

'''
通过threading.Event()可以创建一个事件管理标志，该标志（event）默认为False，event对象主要有四种方法可以调用：

    event.wait(timeout=None)：调用该方法的线程会被阻塞，如果设置了timeout参数，超时后，线程会停止阻塞继续执行；
    event.set()：将event的标志设置为True，调用wait方法的所有线程将被唤醒；
    event.clear()：将event的标志设置为False，调用wait方法的所有线程将被阻塞；
    event.isSet()：判断event的标志是否为True。

'''

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import threading
from time import sleep


def test(n, event):
    while not event.isSet():
        print 'Thread %s is ready' % n
        sleep(1)
    event.wait()

    while event.isSet():
        print 'Thread %s is running' % n
        sleep(1)


if __name__ == '__main__':

    event = threading.Event()
    for i in xrange(0, 2):
        print "i:",i
        th = threading.Thread(target=test, args=(i, event))
        th.start()

    sleep(3)
    print '----- event is set -----'
    event.set()
    sleep(3)
    print '----- event is clear -----'
    event.clear()

运行结果：
i: 0
Thread 0 is ready
i: 1
Thread 1 is ready
Thread 1 is readyThread 0 is ready

Thread 1 is ready
Thread 0 is ready
----- event is set -----Thread 0 is ready

Thread 1 is ready
Thread 1 is runningThread 0 is running

Thread 0 is running
Thread 1 is running
Thread 0 is running----- event is clear -----Thread 1 is running