from threading import Thread

import time

#1. 如果多个线程执行的都是同一个函数的话，各自之间不会有影响，各是个的

def test():

    print("----昨晚喝多了，下次少喝点---")

    time.sleep(1)

for i in range(5):

    t = Thread(target=test)

    t.start()

import threading

import time

class MyThread(threading.Thread):

    def run(self):

        for i in range(3):

            time.sleep(1)

            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字

            print(msg)

if __name__ == '__main__':

    t = MyThread()

    t.start()

[root@master process]# python3 09-thread.py

I'm Thread-1 @ 0

I'm Thread-1 @ 1

I'm Thread-1 @ 2

from threading import Thread

import time

#线程之间共享全局变量

g_num = 100

def work1():

    global g_num

    for i in range(3):

        g_num += 1

    print("----in work1, g_num is %d---"%g_num)

def work2():

    global g_num

    print("----in work2, g_num is %d---"%g_num)

print("---线程创建之前g_num is %d---"%g_num)

t1 = Thread(target=work1)

t1.start()

#延时一会，保证t1线程中的事情做完

time.sleep(1)

t2 = Thread(target=work2)

t2.start()

from threading import Thread

import time

g_num = 0

def test1():

    global g_num

    for i in range(1000000):

        g_num += 1

    print("---test1---g_num=%d"%g_num)

def test2():

    global g_num

    for i in range(1000000):

        g_num += 1

    print("---test2---g_num=%d"%g_num)

p1 = Thread(target=test1)

p1.start()

#time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？

p2 = Thread(target=test2)

p2.start()

print("---g_num=%d---"%g_num)

from threading import Thread

import time

def work1(nums):

    nums.append(44)

    print("----in work1---",nums)

def work2(nums):

    #延时一会，保证t1线程中的事情做完

    time.sleep(1)

    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))

t1.start()

t2 = Thread(target=work2, args=(g_nums,))

t2.start()

from threading import Thread

import time

g_num = 0

g_flag = 1

def test1():

    global g_num

    global g_flag

    if g_flag == 1:

        for i in range(1000000):

            g_num += 1

        g_flag = 0

    print("---test1---g_num=%d"%g_num)

def test2():

    global g_num

    #轮询

    while True:

        if g_flag != 1:

            for i in range(1000000):

                g_num += 1

            break

    print("---test2---g_num=%d"%g_num)

p1 = Thread(target=test1)

p1.start()

#time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？

p2 = Thread(target=test2)

p2.start()

print("---g_num=%d---"%g_num)

from threading import Thread, Lock

import time

g_num = 0

def test1():

    global g_num

    #这个线程和ｔｅｓｔ2线程都在抢着　对这个锁　进行上锁，如果有１方成功的上锁，那么导致另外

    #一方会堵塞（一直等待）到这个锁被解开为止

    mutex.acquire()

    for i in range(1000000):

        g_num += 1

    mutex.release()#用来对mutex指向的这个锁　进行解锁，，，只要开了锁，那么接下来会让所有因为

                    #这个锁　被上了锁　而堵塞的线程　进行抢着上锁

    print("---test1---g_num=%d"%g_num)

def test2():

    global g_num

    mutex.acquire()

    for i in range(1000000):

        g_num += 1

    mutex.release()

    print("---test2---g_num=%d"%g_num)

#创建一把互斥锁，这个锁默认是没有上锁的

mutex = Lock()

p1 = Thread(target=test1)

p1.start()

#time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？

p2 = Thread(target=test2)

p2.start()

print("---g_num=%d---"%g_num)

from threading import Thread

import threading

import time

def test1():

    #注意：

    #   1. 全局变量在多个线程中　共享，为了保证正确运行需要锁

    #   2. 非全局变量在每个线程中　各有一份，不会共享，当然了不需要加锁

    name = threading.current_thread().name

    print("----thread name is %s ----"%name)

    g_num = 100

    if name == "Thread-1":

        g_num += 1

    else:

        time.sleep(2)

    print("--thread is %s----g_num=%d"%(name,g_num))

#def test2():

#    time.sleep(1)

#    g_num = 100

#    print("---test2---g_num=%d"%g_num)

p1 = Thread(target=test1)

p1.start()

p2 = Thread(target=test1)

p2.start()

from threading import Thread,Lock

from time import sleep

class Task1(Thread):

    def run(self):

        while True:

            if lock1.acquire():

                print("------Task 1 -----")

                sleep(0.5)

                lock2.release()

class Task2(Thread):

    def run(self):

        while True:

            if lock2.acquire():

                print("------Task 2 -----")

                sleep(0.5)

                lock3.release()

class Task3(Thread):

    def run(self):

        while True:

            if lock3.acquire():

                print("------Task 3 -----")

                sleep(0.5)

                lock1.release()

#使用Lock创建出的锁默认没有“锁上”

lock1 = Lock()

#创建另外一把锁，并且“锁上”

lock2 = Lock()

lock2.acquire()

#创建另外一把锁，并且“锁上”

lock3 = Lock()

lock3.acquire()

t1 = Task1()

t2 = Task2()

t3 = Task3()

t1.start()

t2.start()

t3.start()

#encoding=utf-8

import threading

import time

#python2中

#from Queue import Queue

#python3中

from queue import Queue

class Producer(threading.Thread):

    def run(self):

        global queue

        count = 0

        while True:

            if queue.qsize() < 1000:

                for i in range(100):

                    count = count +1

                    msg = '生成产品'+str(count)

                    queue.put(msg)

                    print(msg)

            time.sleep(0.5)

class Consumer(threading.Thread):

    def run(self):

        global queue

        while True:

            if queue.qsize() > 100:

                for i in range(3):

                    msg = self.name + '消费了 '+queue.get()

                    print(msg)

            time.sleep(1)

if __name__ == '__main__':

    queue = Queue()

    for i in range(500):

        queue.put('初始产品'+str(i))

    for i in range(2):

        p = Producer()

        p.start()

    for i in range(5):

        c = Consumer()

        c.start()

Theadlocal的作用：不用传参数，用一个全局变量能够完成线程里面所有的数据传递，不会因为下一个线程调用该变量而改变该值
import threading

# 创建全局ThreadLocal对象:

local_school = threading.local()

def process_student():

    # 获取当前线程关联的student:

    std = local_school.student

    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):

    # 绑定ThreadLocal的student:

    local_school.student = name

    process_student()

t1 = threading.Thread(target= process_thread, args=('dongGe',), name='Thread-A')

t2 = threading.Thread(target= process_thread, args=('老王',), name='Thread-B')

t1.start()

t2.start()

from multiprocessing import Pool

import time

import os

def test():

    print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))

    for i in range(3):

        print("----%d---"%i)

        time.sleep(1)

    return "hahah"

def test2(args):

    print("---callback func--pid=%d"%os.getpid())

    print("---callback func--args=%s"%args)

pool = Pool(3)

pool.apply_async(func=test,callback=test2)

#异步的理解：主进程正在做某件事情，突然　来了一件更需要立刻去做的事情，

#那么这种，在父进程去做某件事情的时候　并不知道是什么时候去做，的模式　就称为异步

while True:

    time.sleep(1)

    print("----主进程-pid=%d----"%os.getpid())