#启动一个子进程并等待其结束：

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())

    #创建子进程时，只需要传入一个执行函数和函数的参数，

    #创建一个Process实例，用start()方法启动。

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

    print('Child process will start.')

    p.start()

    #join()可等待子进程结束后再继续往下运行，通常用于进程间的同步。

    p.join()

    print('Child process end.')

结果：

Parent process 928.

Process will start.

Run child process test (929)...

Process end.

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.

import time, threading

# 新线程执行的代码:

def loop():

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

    n =

    while n < :

        n = n +

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

        time.sleep()

    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 >>>

thread LoopThread >>>

thread LoopThread >>>

thread LoopThread >>>

thread LoopThread >>>

thread LoopThread ended.

thread MainThread ended.

#来看看多个线程同时操作一个变量怎么把内容给改乱了

import time, threading

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

balance = 

def change_it(n):

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

    global balance

    balance = balance + n

    balance = balance - n

def run_thread(n):

    for i in range():

        change_it(n)

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

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

t1.start()

t2.start()

t1.join()

t2.join()

print(balance)

import time

from multiprocessing import Process

def func():

    time.sleep()

    print("func1")

if __name__=="__main__":

    Process(target=func).start()

    print()

打印结果：

func1 

先打印999，打印完后等待两秒打印func1

import time

from threading import Thread

def func1():

    while True:

        print('*'*10)

        time.sleep(1)

def func2():

    print('in func2')

    time.sleep(5)

t = Thread(target=func1,)

t.daemon = True

t.start()

t2 = Thread(target=func2,)

t2.start()

t2.join()  #join 语句的执行会等待最后打印“”主线程“”

print('主线程')

**********

in func2

**********

**********

**********

**********

主线程

import time

from threading import Semaphore,Thread

def func(sem,a,b):

    sem.acquire()

    time.sleep(1)

    print(a+b)

    sem.release()

sem = Semaphore(4)

for i in range(10):

    t = Thread(target=func,args=(sem,i,i+5))

    t.start()

# 事件被创建的时候

# False状态

    # wait() 阻塞

# True状态

    # wait() 非阻塞

# clear 设置状态为False

# set  设置状态为True

#  数据库 - 文件夹

#  文件夹里有好多excel表格

    # .能够更方便的对数据进行增删改查

    # .安全访问的机制

#  起两个线程

#  第一个线程 : 连接数据库

        # 等待一个信号 告诉我我们之间的网络是通的

        # 连接数据库

#  第二个线程 : 检测与数据库之间的网络是否连通

        # time.sleep(,)

        # 将事件的状态设置为True

import time

import random

from threading import Thread,Event

def connect_db(e):

    count =

    while count < :

        e.wait(0.5)   # 状态为False的时候,我只等待1s就结束

        if e.is_set() == True:

            print('连接数据库')

            break

        else:

            count +=

            print('第%s次连接失败'%count)

    else:

        raise TimeoutError('数据库连接超时')

def check_web(e):

    time.sleep(random.randint(,))

    e.set()

e = Event()

t1 = Thread(target=connect_db,args=(e,))

t2 = Thread(target=check_web,args=(e,))

t1.start()

t2.start()

# 条件

from threading import Condition

# 条件

# 锁

# acquire release

# 一个条件被创建之初 默认有一个False状态

# False状态 会影响wait一直处于等待状态

# notify(int数据类型)  造钥匙

from threading import Thread,Condition

def func(con,i):

    con.acquire()

    con.wait() # 等钥匙

    print('在第%s个循环里'%i)

    con.release()

con = Condition()

for i in range():

    Thread(target=func,args = (con,i)).start()

while True:

    num = int(input('>>>'))

    con.acquire()

    con.notify(num)  # 造钥匙

    con.release()

import time

from threading import Timer

def func():

    print('时间同步')   #-

while True:

    t = Timer(,func).start()   # 非阻塞的

    time.sleep()

import  queue

q =queue.Queue()

q.put(100)

q.put(200)

q = queue.LifoQueue()#栈 ，先进后出，

q.put()

q.put()

q.put()

print(q.get())

print(q.get())

print(q.get())

q=queue.PriorityQueue() #优先级队列

q.put((,"a"))

q.put((,"b"))

q.put((,"c"))

q.put((,"d"))

print(q.get())

(, 'b')

import time

from concurrent.futures import ThreadPoolExecutor

def func(n):

    time.sleep()

    print(n)

    return n*n

def call_back(m):

    print('结果是 %s'%m.result())

tpool = ThreadPoolExecutor(max_workers=)   #  默认 不要超过cpu个数*

for i in  range():

    tpool.submit(func,i).add_done_callback(call_back)

# tpool.map(func,range())  # 拿不到返回值

# t_lst = []

# for i in  range():

#     t = tpool.submit(func,i)

#     t_lst.append(t)

# tpool.shutdown()  # close+join    #

# print('主线程')

# for t in t_lst:print('***',t.result())

# ftp

# 并发编程