Python 开启线程的2中方式，线程VS进程（守护线程、互斥锁）

from threading import  Thread
    #方式一：（引用系统中thread类）
    def task(name):
        print(‘%s is running‘)
        print(‘%s is done‘)

    if __name__ == ‘__main__‘:
        p=Thread(target=task,args=(‘子线程‘,))
        p.start()


    #方式二：（自定义类）
    class Mythread(Thread):
        def run(self):
            print(‘%s is running‘%self.name)
            print(‘%s is done‘%self.name)

    if __name__ == ‘__main__‘:
        p=Mythread()
        p.start()

第一点:
        1.多个进程内存空间彼此隔离
        2.同一进程下的线程共享该进程内的数据
        
    第二点：
        线程的速度快与进程（因为不需要造名称空间，不需要复制父类的代码）
        from threading import  Thread
        # from multiprocessing import Process
        import time
        x=100
        def task(name):
            global x
            x=50
            print(‘%s is running‘%name)
            time.sleep(3)
            print(‘%s is done‘%name)

        if __name__ == ‘__main__‘:
            # p1=Thread(target=task,args=(‘子线程1‘,))
            # p1=Process(target=task,args=(‘子线程1‘,))
            # p1.start()

            # p.daemon=True #验证二：将p设置成守护进程，它会等到除了守护进程p之外的另外2个进程（p和主进程print(‘主‘)）都结束的时候才死掉

            # p=Thread(target=task,args=(‘子线程‘,))

            #验证三：线程的速度要远快于进程
            # p=Process(target=task,args=(‘子线程‘,))    #使用进程
            # p.start()               #会先打印print=(‘主‘)

            p=Thread(target=task,args=(‘子线程‘,))     #使用线程
            p.start()                #会先打印：子线程 is running

            #验证一：同一进程下的线程共享该进程类的数据
            # print(x)   #在主线程里面去调用x 发现x被子线程已经重新修改并复制，所有结果就是x=50

            print(‘主‘)

#加锁循环对一个共享的数值去减1（主要的作用在于对于共享部分数据，一定要保证用户是逐一串行进来修改值的）
from threading import Thread,Lock
import time

mutex=Lock()  #线程锁：1.大家都能共享到（所以放这个位置）2.加锁让大家逐一去排队运行，运行完一个，x就减1
x=100

def task():
    global x
    mutex.acquire()
    temp=x          #如果不加锁，线程1=100，线程2=100，。。
    time.sleep(0.1)  #如果不加锁，输出会是100，因为等0.1秒的时候，所有的线程都已经是100了
    x=temp-1
    mutex.release()

if __name__ == ‘__main__‘:
    start=time.time()
    t_l=[] #里面放的是thread1-thread100
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()  #线程造出来的时间会非常快
    for t in t_l:
        t.join()  #等待每个线程结束后运行下一步

    print(‘主‘,x)  #这一步肯定是所有的线程都运行完了 
    print(time.time()-start)

from threading import Thread,Lock,RLock
import time

# mutexA=Lock()   #死锁现象就是会存在当放当f1、f2拿着互相的锁，都卡在那里互等对方解锁的现象，导致程序就一直卡在那里
# mutexB=Lock()
mutexA=mutexB=RLock()    #改变死锁就是导入递归锁：递归锁的功能就是可以连续的acquire+1+1...加锁，碰到release-1-1...就会自动解锁
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print(‘%s 拿到了A锁‘ %self.name)

        mutexB.acquire()
        print(‘%s 拿到了B锁‘ %self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print(‘%s 拿到了B锁‘ %self.name)
        time.sleep(0.1)

        mutexA.acquire()
        print(‘%s 拿到了A锁‘ %self.name)
        mutexA.release()

        mutexB.release()


if __name__ == ‘__main__‘:
    for i in range(10):
        t=MyThread()
        t.start()

    # t1=MyThread()
    # t1.start()
    #
    # t2=MyThread()
    # t2.start()
    #
    # t3=MyThread()
    # t3.start()
    print(‘主‘)

# from multiprocessing import Semaphore
#信号量：是控制同一时刻并发执行的任务数  sm=Semaphore(5) ，后面的数字就是信号量
#最多同时可以接收5个人，如果出来1个就解锁一个...最多解锁5个
from threading import Thread,Semaphore,current_thread
import time,random

sm=Semaphore(5)  #代表信号量为5，一次性接收5个值

def go_wc():
    sm.acquire()
    print(‘%s 上厕所ing‘ %current_thread().getName())
    time.sleep(random.randint(1,3))
    sm.release()

if __name__ == ‘__main__‘:
    for i in range(23):
        t=Thread(target=go_wc)
        t.start()