python3 线程练习:

启动3个线程打印递增的数字 ，控制统线程打印 12345 (每行都打印线程名和一个数
字），线程 打印 6, 7, 8, 9, 10 线程 打印 1, 12, 13, 14, 15 接下来再由线程 打印 16 17, 18, 19,
20 ……依此类推，直到打印 75

from concurrent.futures import ThreadPoolExecutor
import threading

# 新建一个类控制线程锁
class MyThread:

    def __init__(self):
        # 当前打印的值
        self.number = 0
        # 控制应由哪个线程执行打印任务
        self.state = 1
        # 使用condition来进行线程间通信
        self.cond = threading.Condition()

    # 打印方法，连续打印5个数字以后就退出当前线程，把执行权限交给下一个线程
    def my_print(self, thread_num):
        try:
            # 为当前线程加锁
            self.cond.acquire()
            # 如果当前线程不是应该执行打印任务的线程，则阻塞当前线程
            while self.state != thread_num:
                self.cond.wait()
            # 打印5个连续数值：
            for i in range(5):
                self.number += 1
                print("thread{0} : {1}".format(thread_num, self.number))
            # 每打印5个数字后，将thread_num即state值加1，控制由下一个线程来执行打印任务
            self.state = self.state % 3+1
            # 唤醒所有线程
            self.cond.notify_all()
        finally:
            # 释放锁
            self.cond.release()

# 线程执行体
def action(mt, thread_num):
    # 控制每个线程要执行MyThread对象的my_print()方法5次
    for i in range(5):
        mt.my_print(thread_num)

# 创建MyThread类对象
mt = MyThread()
# 创建一个包含三个线程的线程池
with ThreadPoolExecutor(max_workers=3) as pool:
    # 启动3个线程
    for i in range(3):
        # 使用线程池启动3个线程
        pool.submit(action, mt, i + 1)

编写两个线程，其中一个线程打印1~52；另一个线程打印A～Z，打印顺序是12A34B56C … 5152Z。该练习题需要利用多线程通信的知识。

import threading, queue
#创建一个只有1个元素的队列
bq = queue.Queue(1)
#创建线程锁
lock = threading.RLock()
def action1(bq):
    for i in range(1, 53, 2):
        # 向队列中放入元素，因为队列只有一个元素，因此放入元素后该线程被阻塞
        bq.put(i)
        print(i, end='')
        print(i + 1, end='')
def action2(bq):
    for i in range(26):
        # 从队列中取出元素，取出元素后，队列为空当前线程被阻塞
        bq.get()
        print(chr(65 + i), end='') 
#创建并启动第一个线程
t1 = threading.Thread(target=action1, args=(bq,))
t1.start()
#创建并启动第二个线程
t2 = threading.Thread(target=action2, args=(bq,))
t2.start()

有4个线程1,2,3,4。线程l的功能是输出l，线程2的功能是输出2，依此类推。现在有4个文件A,B,C,D ，初始都为空。让4个文件最后呈现出如下内容
A：1 2 3 4 1 2…

B: 2 3 4 1 2 3…

C: 3 4 1 2 3 4…

D: 4 1 2 3 4 1…

from concurrent.futures import ThreadPoolExecutor
import threading
import time, os
from pathlib import Path
 
 
# 创建文件写入类
class WriteFile:
 
    def __init__(self):
        # 当前线程ID
        self.current_thread_num = 1
        # 写入文件总数
        self.write_count = 0
 
    # 创建函数向文件写入数字
    def write_num(self, value):
        # 生成文件位置
        with open(self.current_file_name() + ".txt", 'a+') as f:
            f.write(value + " ")
            print(
                "ThreadNum={0} is executing. {1} is written into file: {2}.txt \n"
                .format(self.current_thread_num, value,
                        self.current_file_name()))
            self.write_count += 1
            self.current_thread_num = int(value)
            self.next_thread_num()
 
    # 获取当前写入文件的文件名
    def current_file_name(self):
        '''判断接下来要写入哪个文件'''
        tmp = self.write_count % 4
        name_map = {0: 'A', 1: 'B', 2: 'C', 3: 'D'}
        return name_map[tmp]
 
    # 获取下一个进程的ID
    def next_thread_num(self):
        if self.write_count % 4 == 0:
            if self.current_thread_num < 3:
                self.current_thread_num += 2
            else:
                self.current_thread_num = (self.current_thread_num + 2) % 4
        else:
            if self.current_thread_num == 4:
                self.current_thread_num = 1
            else:
                self.current_thread_num += 1
 
wf = WriteFile()
# 创建Condition对象，用于线程间通信
wf.cond = threading.Condition()
# 如果文件已经存在，先将文件删除
for f in ('A', 'B', 'C', 'D'):
    if Path(f + '.txt').exists():
        os.remove(f + '.txt')
 
# 创建线程体函数
def action(value):
    try:
        # 向每个文件写入6个数字
        for i in range(6):
            try:
                wf.cond.acquire()
                # 保证要写入的值必须与当前线程的id相同
                while int(value) != wf.current_thread_num:
                    wf.cond.wait()
                wf.write_num(value)
                wf.cond.notify_all()
            finally:
                wf.cond.release()
    except Exception as e:
        print("异常{0}".format(e))
 
# 创建一个包含4个线程的线程池
with ThreadPoolExecutor(max_workers=4) as pool:
    # 使用线程池启动4个线程
    for i in range(4):
        pool.submit(action, str(i + 1))