import LOGging
import os
import time
from multiprocessing import Process

logging.basicconfig(level=logging.INFO)


class MyClass:
    """Process 1"""

    def __inIT__(self, *, name: str, age: int) -> None:
        """Init"""

        self.name = name
        self.age = age
        self.logger = logging.getLogger("MyProcess")

    def info(self) -> None:
        """Info"""

        self.logger.info("This is info...")
        basic_info = (self.name, self.age)
        for _ in range(2):
            time.sleep(1)
            print(f"Basic info is {basic_info}.")

    def sing(self) -> None:
        """Sing"""

        self.logger.info("This is sing...")
        for _ in range(3):
            time.sleep(1)
            print(f"{self.name} is singing《reality》now.")


def validation_daemon():
    """Validate daemon"""

    my_process = MyClass(name="zhangsan", age=18)
    start_time = time.time()
    # Creat process
    # daemon=False, 主进程要等待子进程,daemon=True，主进程结束，程序就结束了，不会等待子进程
    # 这里主进程运行了0.003s后，还会继续等待子进程
    process_1 = Process(target=my_process.info, daemon=False)
    process_2 = Process(target=my_process.sing, daemon=False)
    print(f"This is Process, pid is {os.getpid()}")

    # Start
    process_1.start()
    process_2.start()
    end_time = time.time()
    print(f"Run time is {end_time - start_time}") # 主进程最后一行，运行完主进程结束，但是是否等待子进程，取决daemon参数设置


def validation_join():
    """Validate join"""

    my_process = MyClass(name="LiSi", age=20)
    start_time = time.time()
    # Creat process
    process_1 = Process(target=my_process.info, daemon=True)
    process_2 = Process(target=my_process.sing, daemon=True)
    print(f"This is Process, pid is {os.getpid()}")

    # Start
    process_1.start()
    process_2.start()
    # join，主进程等待子进程结束后，再执行后面的代码，那么主进程的运行时间变长（包含等待子进程运行的时间）
    process_1.join()
    process_2.join()
    end_time = time.time()
    print(f"Run time is {end_time - start_time}")

def single_process():
    """Single process """

    my_process = MyClass(name="LiSi", age=20)
    start_time = time.time()
    my_process.info()
    my_process.sing()
    end_time = time.time()
    print(f"Run time is {end_time - start_time}")


if __name__ == '__main__':
    validation_daemon()
    validation_join()
    single_process()  # 单进程执行效率低，时间长

"""多进程的全局变量"""

from multiprocessing import Process

CONSTANT = 10


def funtion_1():
    """Funtion 1"""

    global CONSTANT
    CONSTANT += 1
    print(f"Funtion_1 constant is {CONSTANT}")


def funtion_2():
    """Function 2"""
    global CONSTANT
    CONSTANT += 2
    print(f"Funtion_2 constant is {CONSTANT}")


def funtion_test():
    """Test"""
    F1_process = Process(target=funtion_1)
    f2_process = Process(target=funtion_2)
    f1_process.start()
    f2_process.start()


if __name__ == '__main__':
    funtion_test()
    print(f"The main process constant is {CONSTANT}")  #10 ，因为多个进程之间的资源是不可分享的，因为各个进程是独立占用内存的

"""Queue"""

# 多进程中如何使用队列queue共享数据？----多个进程共享主进程中创建的队列
# 方法：
# 主进程创建队列，然后把队列作为参数传到各个子进程中即可

from multiprocessing import Process, Queue


def fun1(queue):
    """Fun 1
    :param queue:  Queue
    """
    value = queue.get()
    value += 1
    queue.put(value)
    print(f"Fun 1 value is {value}")


def fun2(queue):
    """Fun 2
    :param queue:  Queue
    """
    value = queue.get()
    value += 2
    queue.put(value)
    print(f"Fun 2 value is {value}")


def funtion_multi_process():
    queue = Queue()
    queue.put(0)
    f1_process = Process(target=fun1, args=(queue,), daemon=False)
    f2_process = Process(target=fun2, args=(queue,), daemon=False)
    f1_process.start()
    f2_process.start()
    f1_process.join() # 这里使用join()进行阻塞主进程的话，上面的daemon参数就可以不设置了
    f2_process.join()
    print(f"Main process value is {queue.get()}")


if __name__ == '__main__':
    funtion_multi_process()