from threading import Thread

# 第一种创建方式

def f1(n):

    print('%s号线程任务'%n)

def f2(n):

    print('%s号线程任务'%n)

if __name__ == '__main__':

    t1 = Thread(target=f1,args=(1,))

    t2 = Thread(target=f2,args=(2,))

    t1.start()

    t2.start()

    print('主线程')

# 第二种创建方式

class MyThread(Thread):

    def __init__(self,name):

        # super(MyThread, self).__init__()  和下面super是一样的

        super().__init__()

        self.name = name

    def run(self):

        print('hello girl :' + self.name)

if __name__ == '__main__':

    t = MyThread('alex')

    t.start()

    print('主线程结束')

import os

from threading import Thread

def f1(n):

    print('1号=>',os.getpid())

    print('%s号线程任务' % n)

def f2(n):

    print('2号=>',os.getpid())

    print('%s号线程任务' % n)

if __name__ == '__main__':

    t1 = Thread(target=f1,args=(1,))

    t2 = Thread(target=f2,args=(2,))

    t1.start()

    t2.start()

    print('主线程', os.getpid())

    print('主线程')

# 由于这些线程都是在一个进程中的,所以pid一致

import time

from threading import Thread

num = 100

def f1(n):

    global num

    num = 3

    time.sleep(1)

    print('子线程的num', num)  # 子线程的num 3

if __name__ == '__main__':

    thread = Thread(target=f1,args=(1,))

    thread.start()

    thread.join() # 等待thread执行完在执行下面的代码

    print('主线程的num', num)  # 主线程的num 3

import time

from threading import Thread

from multiprocessing import Process

def f1():

    # io密集型

    # time.sleep(1)

    # 计算型:

    n = 10

    for i in range(10000000):

        n = n + i

if __name__ == '__main__':

    #查看一下20个线程执行20个任务的执行时间

    t_s_time = time.time()

    t_list = []

    for i in range(5):

        t = Thread(target=f1,)

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

    t_e_time = time.time()

    t_dif_time = t_e_time - t_s_time

    #查看一下20个进程执行同样的任务的执行时间

    p_s_time = time.time()

    p_list = []

    for i in range(5):

        p = Process(target=f1,)

        p.start()

        p_list.append(p)

    [pp.join() for pp in p_list]

    p_e_time = time.time()

    p_dif_time = p_e_time - p_s_time

    # print('多线程的IO密集型执行时间:',t_dif_time)  # 1.0017869472503662 还需要减1秒的time.sleep

    # print('多进程的IO密集型执行时间:',p_dif_time)  # 1.2237937450408936  也需要减1秒的time.sleep

    print('多线程的计算密集型执行时间:', t_dif_time)  # 3.58754563331604

    print('多进程的计算密集型执行时间:', p_dif_time)  # 2.1555309295654297

import time

from threading import Lock, Thread

num = 100

def f1(loc):

    # 加锁

    with loc:

        global num

        tmp = num

        tmp -= 1

        time.sleep(0.001)

        num = tmp

        # 上面的代码相当于 num -= 1

if __name__ == '__main__':

    t_loc = Lock()

    t_list = []

    for i in range(10):

        t = Thread(target=f1,args=(t_loc,))

        t.start()

        t_list.append(t)

    [tt.join() for tt in t_list]

    print('主线的num',num)

import time

from threading import Thread,Lock,RLock

def f1(locA,locB):

    locA.acquire()

    print('f1>>1号抢到了A锁')

    time.sleep(1)

    locB.acquire()

    print('f1>>1号抢到了B锁')

    locB.release()

    locA.release()

def f2(locA,locB):

    locB.acquire()

    print('f2>>2号抢到了B锁')

    time.sleep(1)

    locA.acquire()

    print('f2>>2号抢到了A锁')

    locA.release()

    locB.release()

if __name__ == '__main__':

    # locA = locB = Lock()  # 不能这么写,这么写相当于这两个是同一把锁

    locA = Lock()

    locB = Lock()

    t1 = Thread(target=f1,args=(locA,locB))

    t2 = Thread(target=f2,args=(locA,locB))

    t1.start()

    t2.start()

# 上面的代码表示f1 先抢到了A锁,同时f2 抢到了B锁,一秒后f1想去想B锁,同时f2想去抢A锁,

# 由于锁需要先放开才能继续抢,导致了死锁现象　

import time

from threading import Thread, Lock, RLock

def f1(locA, locB):

    locA.acquire()

    print('f1>>1号抢到了A锁')

    time.sleep(1)

    locB.acquire()

    print('f1>>1号抢到了B锁')

    locB.release()

    locA.release()

def f2(locA, locB):

    locB.acquire()

    print('f2>>2号抢到了B锁')

    locA.acquire()

    time.sleep(1)

    print('f2>>2号抢到了A锁')

    locA.release()

    locB.release()

if __name__ == '__main__':

    locA = locB = RLock()  #递归锁,维护一个计数器,acquire一次就加1,release就减1 , acquire等于0的时候才可以抢

    t1 = Thread(target=f1, args=(locA, locB))

    t2 = Thread(target=f2, args=(locA, locB))

    t1.start()

    t2.start()

import time

from threading import Thread

from multiprocessing import Process

#守护进程:主进程代码执行运行结束,守护进程随之结束

#守护线程:守护线程会等待所有非守护线程运行结束才结束

def f1():

    time.sleep(2)

    print('1号线程')

def f2():

    time.sleep(3)

    print('2号线程')

if __name__ == '__main__':

    t1 = Thread(target=f1,)

    t2 = Thread(target=f2,)

    # t1.daemon = True  # 1号进程 和 2 号进程都会打印

    t2.daemon = True # 不会打印2号进程

    t1.start()

    t2.start()

    print('主线程结束')

    # 与进程对比

    p1 = Process(target=f1, )

    p2 = Process(target=f2, )

    p1.daemon = True  # 只会打印 2号进程

    p2.daemon = True  # 只会打印1号进程

    p1.start()

    p2.start()

    print('主进程结束')