多线程和mysql

多线程

1、多线程的定义：

什么是线程：
线程是操作系统能够进行运算调度的最小单位（程序执行流的最小单元）。它被包含在进程之中，
是进程中的实际运作单位。一个进程中可以并发多个线程，每条线程并行执行不同的任务。
(线程是进程中的一个实体，是被系统独立调度和分派的基本单元)

线程和进程的区别

（1）线程共享内存空间；进程的内存是独立的

（2）同一个进程的线程之间可以直接交流；两个进程想通信，必须通过一个中间代理来实现

（3）创建新线程很简单；创建新进程需要对其父进程进行一次克隆

（4）一个线程可以控制和操作同一进程里的其他线程；但是进程只能操作子进程

（5）改变主线程（如优先权），可能会影响其它线程；改变父进程，不影响子进程

现在pc都是多核的，使用多线程能充分利用 CPU 来提供程序的执行效率
线程：
   线程是一个基本的 CPU 执行单元，它必须依托于进程存活
进程：
   进程是指一个程序在给定数据集合上的一次执行过程，是系统进行资源分配和运行调用的独立单位。
   可以简单地理解为操作系统中正在执行的程序。也就说，每个应用程序都有一个自己的进程

每一个进程启动时都会最先产生一个线程，即主线程。然后主线程会再创建其他的子线程

两者的区别
线程必须在某个进程中执行。
一个进程可包含多个线程，其中有且只有一个主线程。
多线程共享同个地址空间、打开的文件以及其他资源。
多进程共享物理内存、磁盘、打印机以及其他资源。

单线程：

例1：

from time import ctime, sleep

def music(a):
    for i in range(2):
        print 'I was listening to %s. %s' % (a, ctime())
        sleep(1)

def movie(b):
    for i in range(2):
        print 'I was watching to %s. %s' % (b, ctime())
        sleep(5)

music('告白气球')
movie('战狼')
print 'all over %s' % ctime()

多线程和mysql

总结：单线程, 之前的操作系统处理问题都是单任务的，如果我想做听音乐和看电影两件事，那么一定要先排一下顺序，然后按顺序执行。即一个任务只能在上一个任务完成后执行。

多线程：

情况1：

python有两个模块实现多线程thread 和threading ，因为threading 弥补了thread 的一些缺点。

import threading
from time import sleep, ctime

def music(a):
    for i in range(2):
        print 'I was listening to %s. %s' % (a, ctime())
        sleep(1)

def movie(b):
    for i in range(2):
        print 'I was watching to %s. %s' % (b, ctime())
        sleep(5)

# 创建threads列表
threads = []

t1 = threading.Thread(target=music, args=('告白气球',))
threads.append(t1)
t2 = threading.Thread(target=movie, args=('战狼',))
threads.append(t2)
for t in threads:
    # 当父线程执行完最后一条语句后：print 'all over %s' %ctime()
    # 没有等待子线程，直接就退出了，同时我们的子线程也一同结束
    t.setDaemon(True)
    t.start()
print 'all over %s' % ctime()

多线程和mysql

总结：

从结果中可以看出，主线程没有等待子线程，执行后就直接就退出了程序执行，同时我们的子线程也一同结束。

多线程

情况2：

例1：

import threading
from time import sleep, ctime

def music(a):
    for i in range(2):
        print 'I was listening to %s. %s' %(a,ctime())
        sleep(1)
def movie(b):
    for i in range(2):
        print 'I was watching to %s. %s' %(b,ctime())
        sleep(5)

# 创建threads列表
threads=[]

t1 = threading.Thread(target=music,args=('告白气球',))
threads.append(t1)
t2 = threading.Thread(target=movie,args=('泰坦尼克号',))
threads.append(t2)
for t in threads:
    t.setDaemon(True)
    t.start()
# join()的作用是，在子线程完成之前，这个子线程的父线程将一直被阻塞
t.join()
print 'all over %s' %ctime()

多线程和mysql

总结：

在子线程完成之前，这个子线程的父线程将一直被阻塞。也就是说music 和move 是同时执行。且主线程在等待子线程，没有直接结束。其中的关键是join()

join()的作用是，在子线程完成之前，这个子线程的父线程将一直被阻塞.

故主线程是在子线程执行完之后才执行。

例2：
import time
from threading import Thread

def Foo(arg):
    for item in range(10):
        print item
        time.sleep(1)

print 'before'
t1 = Thread(target=Foo, args=(1,))
t1.setDaemon(True)
t1.start()
print 'after'
"""
主线程没有结束，子线程还会执行
什么时候主线程执行完了，子线程跟着主线程一起销毁了
"""
time.sleep(5)

多线程和mysql

总结：

从结果中可看到，主线程和子线程一起执行，但是主线程执行完成后并没有停止执行，而是子线程继续执行。

例3：

import time
from threading import Thread


def Foo(arg):
    for item in range(10):
        print item
        time.sleep(1)


print 'before'
t1 = Thread(target=Foo, args=(1,))
# t1.setDaemon(True)
t1.start()
# 主线程到join()不往下走了，直到到子线程执行完了
t1.join(5)
print 'after'
"""
主线程没有结束，子线程还会执行
什么时候主线程执行完了，子线程跟着主线程一起销毁了
"""
# time.sleep(5)

多线程和mysql

线程和函数建立关系

from threading import Thread

def Foo(arg):
    print arg

print 'before'

# 让线程和函数建立关系
t1 = Thread(target=Foo, args=(1,))
t1.start()
print t1.getName()
t2 = Thread(target=Foo, args=(2,))
t2.start()
print t2.getName()
print 'after'

多线程和mysql

mysql

import MySQLdb

# 打开门
conn = MySQLdb.Connect(host ='127.0.0.1',user='root',passwd='dd',db='python3')

# 伸出手
cur = conn.cursor() # 创建一个手

# 拿东西
# 这个操作影响了多少行(有多少行被操作了)
reCount = cur.execute('select * from userInfo')

# 把手伸回来
cur.close()
# 把门观赏
conn.close()

print reCount

多线程

mysql

相关推荐