import threading

import time

def sayhi(num): #定义每个线程要运行的函数

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例

    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

    t1.start() #启动线程

    t2.start() #启动另一个线程

    print(t1.getName()) #获取线程名

    print(t2.getName())

import threading

import time

class MyThread(threading.Thread):

    def __init__(self,num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):#定义每个线程要运行的函数

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()

import time

import threading

def addNum():

    global num #在每个线程中都获取这个全局变量

    print('--get num:',num )

    time.sleep(1)

    num  -=1 #对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕

    t.join()

print('final num:', num )

import time

import threading

def addNum():

    global num #在每个线程中都获取这个全局变量

    print('--get num:',num )

    time.sleep(1)

    lock.acquire() #修改数据前加锁

    num  -=1 #对此公共变量进行-1操作

    lock.release() #修改后释放

num = 100  #设定一个共享变量

thread_list = []

lock = threading.Lock() #生成全局锁

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕

    t.join()

print('final num:', num )

import threading,time

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num +=1

    lock.release()

    return num

def run2():

    print("grab the second part data")

    lock.acquire()

    global  num2

    num2+=1

    lock.release()

    return num2

def run3():

    lock.acquire()

    res = run1()

    print('--------between run1 and run2-----')

    res2 = run2()

    lock.release()

    print(res,res2)

if __name__ == '__main__':

    num,num2 = 0,0

    lock = threading.RLock()

    for i in range(10):

        t = threading.Thread(target=run3)

        t.start()

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print('----all threads done---')

    print(num,num2)

import threading,time

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

if __name__ == '__main__':

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print('----all threads done---')

    print(num)

import threading,time

import random

def light():

    if not event.isSet():

        event.set() #wait就不阻塞 #绿灯状态

    count = 0

    while True:

        if count < 10:

            print('\033[42;1m--green light on---\033[0m')

        elif count <13:

            print('\033[43;1m--yellow light on---\033[0m')

        elif count <20:

            if event.isSet():

                event.clear()

            print('\033[41;1m--red light on---\033[0m')

        else:

            count = 0

            event.set() #打开绿灯

        time.sleep(1)

        count +=1

def car(n):

    while 1:

        time.sleep(random.randrange(10))

        if  event.isSet(): #绿灯

            print("car [%s] is running.." % n)

        else:

            print("car [%s] is waiting for the red light.." %n)

if __name__ == '__main__':

    event = threading.Event()

    Light = threading.Thread(target=light)

    Light.start()

    for i in range(3):

        t = threading.Thread(target=car,args=(i,))

        t.start()

#_*_coding:utf-8_*_

__author__ = 'Alex Li'

import threading

import time

import random

def door():

    door_open_time_counter = 0

    while True:

        if door_swiping_event.is_set():

            print("\033[32;1mdoor opening....\033[0m")

            door_open_time_counter +=1

        else:

            print("\033[31;1mdoor closed...., swipe to open.\033[0m")

            door_open_time_counter = 0 #清空计时器

            door_swiping_event.wait()

        if door_open_time_counter > 3:#门开了已经3s了,该关了

            door_swiping_event.clear()

        time.sleep(0.5)

def staff(n):

    print("staff [%s] is comming..." % n )

    while True:

        if door_swiping_event.is_set():

            print("\033[34;1mdoor is opened, passing.....\033[0m")

            break

        else:

            print("staff [%s] sees door got closed, swipping the card....." % n)

            print(door_swiping_event.set())

            door_swiping_event.set()

            print("after set ",door_swiping_event.set())

        time.sleep(0.5)

door_swiping_event  = threading.Event() #设置事件

door_thread = threading.Thread(target=door)

door_thread.start()

for i in range(5):

    p = threading.Thread(target=staff,args=(i,))

    time.sleep(random.randrange(3))

    p.start()

import threading

def run(n):

    con.acquire()

    con.wait()

    print("run the thread: %s" %n)

    con.release()

if __name__ == '__main__':

    con = threading.Condition()

    for i in range(10):

        t = threading.Thread(target=run, args=(i,))

        t.start()

    while True:

        inp = input('>>>')

        if inp == 'q':

            break

        con.acquire()

        con.notify(int(inp))

        con.release()

def condition_func():

    ret = False
    inp = input('>>>')
    if inp == '1':
        ret = True

    return ret

def run(n):
    con.acquire()
    con.wait_for(condition_func)
    print("run the thread: %s" %n)
    con.release()

if __name__ == '__main__':

    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start()

def hello():

    print("hello, world")

t = Timer(30.0, hello)

t.start()  # after 30 seconds, "hello, world" will be printed

    先进先出  q = Queue.Queue(maxsize)

    后进先出  a = Queue.LifoQueue(maxsize)

    优先级  Queue.PriorityQueue(maxsize)

    Queue.qsize() 返回队列的大小

    Queue.empty() 如果队列为空，返回True,反之False

    Queue.full() 如果队列满了，返回True,反之False

    Queue.full 与 maxsize 大小对应

    Queue.put(item) 写入队列，timeout等待时间   非阻塞

    Queue.get([block[, timeout]]) 获取队列，timeout等待时间

    Queue.get_nowait() 相当Queue.get(False)

    Queue.put_nowait(item) 相当Queue.put(item, False)

    Queue.task_done() 在完成一项工作之后，函数向任务已经完成的队列发送一个信号

    Queue.join()： 实际上意味着等到队列为空，再执行别的操作

参见

collections.deque是无上限的队列的替换实现，有着快速的原子append()和popleft()操作，且不需要锁。

import queue

# q = queue.Queue(2)

#

# q.put(1)

# q.put(2)

# #q.put(3)

# #q.put_nowait(3)

#

# print(q.empty())

# print(q.full())

#

# print(q.get())

# print(q.get())

权重：

q = queue.PriorityQueue()

# q.put((3,'aaaaa'))

# q.put((3,'bbbbb'))

# q.put((1,'ccccc'))

# q.put((3,'ddddd'))

q.put([6,'alex'])

q.put([3,'jack'])

q.put([5,'rain'])

print(q.get())

print(q.get())

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

Python GIL其实是功能和性能之间权衡后的产物，它尤其存在的合理性，也有较难改变的客观因素。从本分的分析中，我们可以做以下一些简单的总结：

- 因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能

- 如果对并行计算性能较高的程序可以考虑把核心部分也成C模块，或者索性用其他语言实现

- GIL在较长一段时间内将会继续存在，但是会不断对其进行改进

#!/usr/bin/env python

#-*- coding:utf-8 -*- 

import threading

import queue

import time

def consumer(name):

    while True:

        print('%s 取到骨头[%s]并吃了' % (name,q.get()))

        time.sleep(0.5)

        q.task_done()

def producer(name):

    count = 0

    #while q.qsize() <5:

    for i in range(10):

        print('%s生成了骨头' %name,count)

        q.put(count)

        count += 1

        time.sleep(0.3)

    q.join()

    print("------吃完了-------")

#生成一个队列

q = queue.Queue(maxsize=4)

#生成两个线程

p = threading.Thread(target=producer,args=('Tom',))

#p2 = threading.Thread(target=producer,args=('Tom',))

c = threading.Thread(target=consumer,args=('Jack',))

p.start()

#p2.start()

c.start()

import time,random

import queue,threading

q = queue.Queue()

def Producer(name):

  count = 0

  while count <20:

    time.sleep(random.randrange(3))

    q.put(count)

    print('Producer %s has produced %s baozi..' %(name, count))

    count +=1

def Consumer(name):

  count = 0

  while count <20:

    time.sleep(random.randrange(4))

    if not q.empty():

        data = q.get()

        print(data)

        print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))

    else:

        print("-----no baozi anymore----")

    count +=1

p1 = threading.Thread(target=Producer, args=('A',))

c1 = threading.Thread(target=Consumer, args=('B',))

p1.start()

c1.start()

#!/usr/bin/env python

#-*- coding:utf-8 -*- 

# !/usr/bin/env python

import threading, time

import queue  # 导入消息队列模块

import random  # 导入随机数模块，是为了模拟生产者与消费者速度不一致的情形

q = queue.Queue()  # 实例化一个对象

def Producer(name):  # 生产者函数

    for i in range(20):

        q.put(i)  # 将结果放入消息队列中

        print('\033[32;1mProducer %s has made %s baozi....\033[0m' % (name, i))

        time.sleep(random.randrange(3))  # 生产者的生产速度，3s内

def Consumer(name):  # 消费者函数

    count = 0

    while count < 20:

        data = q.get()  # 取用消息队列中存放的结果

        print('\033[31;1mConsumer %s has eatem %s baozi...chihuo...\033[0m' % (name, data))

        count += 1

        time.sleep(random.randrange(4))  # 消费者的消费速度，4s内

p = threading.Thread(target=Producer, args=('Tom',))

c = threading.Thread(target=Consumer, args=('Jack',))

p.start()

c.start()

import multiprocessing
import time

def worker(interval):
    n = 5
    while n > 0:
        print("The time is {0}".format(time.ctime()))
        time.sleep(interval)
        n -= 1

if __name__ == "__main__":
    p = multiprocessing.Process(target=worker, args=(3,))
    p.start()
    print("p.pid:", p.pid)

    print("p.name:", p.name)

    print("p.is_alive:", p.is_alive())

p.pid: 15084
p.name: Process-1
p.is_alive: True
The time is Mon Dec 12 11:31:52 2016
The time is Mon Dec 12 11:31:55 2016
The time is Mon Dec 12 11:31:58 2016
The time is Mon Dec 12 11:32:01 2016
The time is Mon Dec 12 11:32:04 2016

import os

print('Process (%s) start...' % os.getpid())

# Only works on Unix/Linux/Mac:

pid = os.fork()

if pid == 0:

    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))

else:

    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))

Process (876) start...

I (876) just created a child process (877).

I am child process (877) and my parent is 876.

from multiprocessing import Process

import os

# 子进程要执行的代码

def run_proc(name):

    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':

    print('Parent process %s.' % os.getpid())

    p = Process(target=run_proc, args=('test',))

    print('Child process will start.')

    p.start()

    p.join()

    print('Child process end.')

Parent process 928.

Process will start.

Run child process test (929)...

Process end.

from multiprocessing import Pool

import os, time, random

def long_time_task(name):

    print('Run task %s (%s)...' % (name, os.getpid()))

    start = time.time()

    time.sleep(random.random() * 3)

    end = time.time()

    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':

    print('Parent process %s.' % os.getpid())

    p = Pool(4)

    for i in range(5):

        p.apply_async(long_time_task, args=(i,))

    print('Waiting for all subprocesses done...')

    p.close()

    p.join()

    print('All subprocesses done.')

Parent process 669.

Waiting for all subprocesses done...

Run task 0 (671)...

Run task 1 (672)...

Run task 2 (673)...

Run task 3 (674)...

Task 2 runs 0.14 seconds.

Run task 4 (673)...

Task 1 runs 0.27 seconds.

Task 3 runs 0.86 seconds.

Task 0 runs 1.41 seconds.

Task 4 runs 1.91 seconds.

All subprocesses done.

p = Pool(5)

import subprocess

print('$ nslookup www.python.org')

r = subprocess.call(['nslookup', 'www.python.org'])

print('Exit code:', r)

$ nslookup www.python.org

Server:        192.168.19.4

Address:    192.168.19.4#53

Non-authoritative answer:

www.python.org    canonical name = python.map.fastly.net.

Name:    python.map.fastly.net

Address: 199.27.79.223

Exit code: 0

import subprocess

print('$ nslookup')

p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

output, err = p.communicate(b'set q=mx\npython.org\nexit\n')

print(output.decode('utf-8'))

print('Exit code:', p.returncode)

set q=mx

python.org

exit

$ nslookup

Server:        192.168.19.4

Address:    192.168.19.4#53

Non-authoritative answer:

python.org    mail exchanger = 50 mail.python.org.

Authoritative answers can be found from:

mail.python.org    internet address = 82.94.164.166

mail.python.org    has AAAA address 2001:888:2000:d::a6

Exit code: 0

from multiprocessing import Process, Queue

import os, time, random

# 写数据进程执行的代码:

def write(q):

    print('Process to write: %s' % os.getpid())

    for value in ['A', 'B', 'C']:

        print('Put %s to queue...' % value)

        q.put(value)

        time.sleep(random.random())

# 读数据进程执行的代码:

def read(q):

    print('Process to read: %s' % os.getpid())

    while True:

        value = q.get(True)

        print('Get %s from queue.' % value)

if __name__=='__main__':

    # 父进程创建Queue，并传给各个子进程：

    q = Queue()

    pw = Process(target=write, args=(q,))

    pr = Process(target=read, args=(q,))

    # 启动子进程pw，写入:

    pw.start()

    # 启动子进程pr，读取:

    pr.start()

    # 等待pw结束:

    pw.join()

    # pr进程里是死循环，无法等待其结束，只能强行终止:

    pr.terminate()

Process to write: 50563

Put A to queue...

Process to read: 50564

Get A from queue.

Put B to queue...

Get B from queue.

Put C to queue...

Get C from queue.

_thread.start_new_thread ( function, args[, kwargs] )

#!/usr/bin/python3

import _thread

import time

# 为线程定义一个函数

def print_time( threadName, delay):

   count = 0

   while count < 5:

      time.sleep(delay)

      count += 1

      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# 创建两个线程

try:

   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )

   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )

except:

   print ("Error: 无法启动线程")

while 1:

   pass

Thread-1: Wed Apr  6 11:36:31 2016

Thread-1: Wed Apr  6 11:36:33 2016

Thread-2: Wed Apr  6 11:36:33 2016

Thread-1: Wed Apr  6 11:36:35 2016

Thread-1: Wed Apr  6 11:36:37 2016

Thread-2: Wed Apr  6 11:36:37 2016

Thread-1: Wed Apr  6 11:36:39 2016

Thread-2: Wed Apr  6 11:36:41 2016

Thread-2: Wed Apr  6 11:36:45 2016

Thread-2: Wed Apr  6 11:36:49 2016

import time, threading

# 新线程执行的代码:

def loop():

    print('thread %s is running...' % threading.current_thread().name)

    n = 0

    while n < 5:

        n = n + 1

        print('thread %s >>> %s' % (threading.current_thread().name, n))

        time.sleep(1)

    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)

t = threading.Thread(target=loop, name='LoopThread')

t.start()

t.join()

print('thread %s ended.' % threading.current_thread().name)

thread MainThread is running...

thread LoopThread is running...

thread LoopThread >>> 1

thread LoopThread >>> 2

thread LoopThread >>> 3

thread LoopThread >>> 4

thread LoopThread >>> 5

thread LoopThread ended.

thread MainThread ended.

import time, threading

# 假定这是你的银行存款:

balance = 0

def change_it(n):

    # 先存后取，结果应该为0:

    global balance

    balance = balance + n

    balance = balance - n

def run_thread(n):

    for i in range(100000):

        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))

t2 = threading.Thread(target=run_thread, args=(8,))

t1.start()

t2.start()

t1.join()

t2.join()

print(balance)

balance = balance + n

x = balance + n

balance = x

初始值 balance = 0

t1: x1 = balance + 5 # x1 = 0 + 5 = 5

t1: balance = x1     # balance = 5

t1: x1 = balance - 5 # x1 = 5 - 5 = 0

t1: balance = x1     # balance = 0

t2: x2 = balance + 8 # x2 = 0 + 8 = 8

t2: balance = x2     # balance = 8

t2: x2 = balance - 8 # x2 = 8 - 8 = 0

t2: balance = x2     # balance = 0

结果 balance = 0

初始值 balance = 0

t1: x1 = balance + 5  # x1 = 0 + 5 = 5

t2: x2 = balance + 8  # x2 = 0 + 8 = 8

t2: balance = x2      # balance = 8

t1: balance = x1      # balance = 5

t1: x1 = balance - 5  # x1 = 5 - 5 = 0

t1: balance = x1      # balance = 0

t2: x2 = balance - 8  # x2 = 0 - 8 = -8

t2: balance = x2   # balance = -8

结果 balance = -8

balance = 0

lock = threading.Lock()

def run_thread(n):

    for i in range(100000):

        # 先要获取锁:

        lock.acquire()

        try:

            # 放心地改吧:

            change_it(n)

        finally:

            # 改完了一定要释放锁:

            lock.release()

#!/usr/bin/python3

import threading

import time

class myThread (threading.Thread):

    def __init__(self, threadID, name, counter):

        threading.Thread.__init__(self)

        self.threadID = threadID

        self.name = name

        self.counter = counter

    def run(self):

        print ("开启线程： " + self.name)

        # 获取锁，用于线程同步

        threadLock.acquire()

        print_time(self.name, self.counter, 3)

        # 释放锁，开启下一个线程

        threadLock.release()

def print_time(threadName, delay, counter):

    while counter:

        time.sleep(delay)

        print ("%s: %s" % (threadName, time.ctime(time.time())))

        counter -= 1

threadLock = threading.Lock()

threads = []

# 创建新线程

thread1 = myThread(1, "Thread-1", 1)

thread2 = myThread(2, "Thread-2", 2)

# 开启新线程

thread1.start()

thread2.start()

# 添加线程到线程列表

threads.append(thread1)

threads.append(thread2)

# 等待所有线程完成

for t in threads:

    t.join()

print ("退出主线程")

开启线程： Thread-1

开启线程： Thread-2

Thread-1: Wed Apr  6 11:52:57 2016

Thread-1: Wed Apr  6 11:52:58 2016

Thread-1: Wed Apr  6 11:52:59 2016

Thread-2: Wed Apr  6 11:53:01 2016

Thread-2: Wed Apr  6 11:53:03 2016

Thread-2: Wed Apr  6 11:53:05 2016

退出主线程

import threading, multiprocessing

def loop():

    x = 0

    while True:

        x = x ^ 1

for i in range(multiprocessing.cpu_count()):

    t = threading.Thread(target=loop)

    t.start()

from  multiprocessing import Process,Pool

import time

def Foo(i):

    time.sleep(2)

    return i+100

def Bar(arg):

    print('-->exec done:',arg)

pool = Pool(5)

for i in range(10):

    pool.apply_async(func=Foo, args=(i,),callback=Bar)

    #pool.apply(func=Foo, args=(i,))

print('end')

pool.close()

pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。