多线程

# 2020年11月17日18:52:31
while True:
    try:
        n = int(input())
        print("ABCD"*n)
    except:
        break
        

"""
思路，四个锁上了的锁， 交给 4个线程去用
当能获取到锁后，释放下一个需要的锁 (但不释放自己的锁，需要等 "前面"一个 来释放)

准备就绪后，用主线程打开第一个锁

"""

from threading import Thread, Lock


def print_char(char, times, in_lock: Lock, out_lock: Lock):
    for _ in range(times):
        in_lock.acquire()
        print(char, end="")
        out_lock.release()


times = int(input())
locks = []
threads = []
for _ in range(4):
    lock = Lock()
    lock.acquire()
    locks.append(lock)

for i, char in enumerate("ABCD"):
    threads.append(Thread(target=print_char, args=(char, times, locks[i], locks[(i + 1) % 4])))

for thread in threads:
    thread.start()

locks[0].release()

for thread in threads:
    thread.join()
print("")

while True:
    try:
        import threading
        # 给每个线程定义锁
        a_lock = threading.Lock()
        b_lock = threading.Lock()
        c_lock = threading.Lock()
        d_lock = threading.Lock()
        count = int(input()) * 4  # 每个字母输出n次,一个4n次输出
        def show_a():
            global count
            while count >= 4:
                a_lock.acquire()
                print("A", end="")
                b_lock.release()
                count -= 1
        def show_b():
            global count
            while count >= 3:
                b_lock.acquire()
                print("B", end="")
                c_lock.release()
                count -= 1
        def show_c():
            global count
            while count >= 2:
                c_lock.acquire()
                print("C", end="")
                d_lock.release()
                count -= 1
        def show_d():
            global count
            while count >= 1:
                d_lock.acquire()
                print("D", end="")
                a_lock.release()
                count -= 1
        thread_list = []
        func_list = [show_a, show_b, show_c, show_d]
        for func in func_list:
            thread = threading.Thread(target=func)
            thread_list.append(thread)
        # 最先输出A，其他线程暂时锁住
        b_lock.acquire()
        c_lock.acquire()
        d_lock.acquire()
        for th in thread_list:
            th.setDaemon(True)
            th.start()  # 开始线程
        for th in thread_list:
            th.join()  # 主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程才终止
        # print("final count", count)
    except:
        break

这段代码在本地IDE测试还有在线自测都没有问题，为什么在提交运行的时候会出现输入22本应该输出长度为88的字符串，却输出了长度为1508的字符串呢？最后打印的count已经变为0，线程也都终止了，为什么还会出现这种情况呢？（备注：本地测试和在线自测输入22可以得到正确结果）

# python 版本的多线程实现，参数是传入的
# 很多抖机灵的做法不用线程，其实不妥，不满足题目要求
# 此代码参考了诸多大神的，并最终实现了参数的传入，再次一并向各位大神表示感谢

import threading
 
class MyThread1(threading.Thread):
    
    def __init__(self, args): 
        super(MyThread1, self).__init__()
        self.args = args
    
    def run(self):
        cou=self.args
        global g_write, mutex , cou
        while cou>0:
            if mutex.acquire(1):
                if g_write[-1] == "D":
                    g_write.append("A")
                mutex.release()

class MyThread2(threading.Thread):
    def run(self):
        global g_write, mutex, cou
        while cou>0:
            if mutex.acquire(1):
                if g_write[-1] == "A":
                    g_write.append("B")
                mutex.release()

class MyThread3(threading.Thread):
    def run(self):
        global g_write, mutex, cou
        while cou>0:
            if mutex.acquire(1):
                if g_write[-1] == "B":
                    g_write.append("C")
                mutex.release()

class MyThread4(threading.Thread):
    def run(self):
        global g_write, mutex, cou
        while cou>0:
            if mutex.acquire(1):
                if g_write[-1] == "C":
                    g_write.append("D")
                    cou -= 1
                    if cou <= 0:
                        print(''.join(g_write))
                        mutex.release()
                        break;
                mutex.release()




while True:
    try:
        ins = int(input())
    except:
        break;
    g_write = ["A"]

    mutex = threading.Lock()
    tsk = []
    tsk.append(MyThread1(ins)) 
    tsk.append(MyThread2())
    tsk.append(MyThread3())
    tsk.append(MyThread4())

    for each in tsk:
        each.start()
    for each in tsk:
        each.join()

#!usr/bin/env python
while 1:
    try:
        num = int(raw_input())
        print 'ABCD'*num
    except:
        break

# -*- coding: utf-8 -*-
# !/usr/bin/python3
from threading import Thread

s = ''


def method(a):
    global s
    s += a


while True:
    try:
        m = int(input())
        s = ''

        for i in range(m):
            thread_a = Thread(target=method('A'))
            thread_b = Thread(target=method('B'))
            thread_c = Thread(target=method('C'))
            thread_d = Thread(target=method('D'))

            thread_a.start()
            thread_b.start()
            thread_c.start()
            thread_d.start()

        print(s)

    except:
        break
        

while True:
    try:
        input_int = int(input())
        re = 'ABCD'*input_int
        print(re)
    except:
        break

while True:
    try:
        n=int(input().strip())
        #print(n)
        result=''
        for i in range(n):
            result+='ABCD'
        print(result)
    except:
        break

while True:
    try:
        print("ABCD"*int(input()))
    except:
        break