python进程线程协程（一）

1.线程的基础调用：

import threading


def loop(n):
    ''' 线程要执行的代码 '''
    for i in range(n):
    	# 输出：  name:Thread-1
        print('name:{0}'.format(threading.current_thread().name))
        print(i)


def use_threading():
    ''' 调用线程实现 '''
    t1 = threading.Thread(target=loop, args=(5,))
    # 打印主线程名：  name:MainThread
    print('name:{0}'.format(threading.current_thread().name))
    t1.start()
    t1.join()


if __name__ == '__main__':
    use_threading()

控制台打印输出为：

name:MainThread
name:Thread-1
0
name:Thread-1
1
name:Thread-1
2
name:Thread-1
3
name:Thread-1
4

2.使用面向对象的用法，重写run方法：

import threading


class MyThreading(threading.Thread):
    n = 5

    def run(self):
        for i in range(self.n):
            current_threading_name = threading.current_thread()
            print('name:{0}'.format(current_threading_name))


if __name__ == '__main__':
    t = MyThreading(name='mythread-oop-1')
    t.start()
    t.join()

生成5个线程，线程名均为指定名’mythread-oop-1’

3.使用线程池：

import threading
import time
from multiprocessing.dummy import Pool


def run(n):
    '''线程要执行的任务'''
    time.sleep(2)
    print('name:{0},num:{1}'.format(threading.current_thread(),n))


def use_pool():
    ''' 假设有100个任务，电脑仅支持同时运行10个线程，
    	使用进程中的线程池实现 '''
    t0 = time.time()
    my_pool = Pool(10)
    n_list = range(100)
    # results = [pool.apply_async(calculate, t) for t in TASKS]
    for n in n_list:
        my_pool.apply(run, args=(n,))
    # # 或者使用map函数
    # # my_pool.map(run, n_list)
    my_pool.close()
    my_pool.join()
    # print(rest)
    print(time.time() - t0)


if __name__ == '__main__':
    use_pool()

使用的线程均为线程池中的线程，重复利用
或者可以使用ThreadPoolExecutor：

from concurrent.futures.thread import ThreadPoolExecutor
# 线程池 ThreadPoolExecutor
def use_executor():
    n_list = [10 for i in range(10)]
    print('n_list:{0}'.format(n_list))

    with ThreadPoolExecutor(max_workers=10) as t:
        t.map(run, n_list)

3.线程锁
lock不能重复锁，否则会一直等待锁释放，造成死锁，rlock则可以重复锁
当设置线程锁时，要等待加锁的部分执行结束，释放锁，另外的线程才能使用锁并执行代码

class ChangedBalanceThread(threading.Thread):
    def __init__(self, num, lock, *args, **kwargs):
        self.num = num
        self.lock = lock
        super(ChangedBalanceThread, self).__init__(*args, **kwargs)

    def run(self):
        with self.lock:
            print('pid:{0},name:{1}'.format(os.getpid(),self.name))
            change_balance(self.num)


if __name__ == '__main__':
    lock = threading.Lock()
    t1 = ChangedBalanceThread(100, lock)
    t2 = ChangedBalanceThread(100, lock)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

其中change_balance(num)是要加锁的代码，仅当change_balance执行结束，释放锁之后，t2才能调用

pid:40144,name:Thread-1
# 此处省略change_balance函数的打印输出 #
pid:40144,name:Thread-2
# 此处省略change_balance函数的打印输出 #

python进程线程协程（一）

猜你喜欢