多线程

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

分类:

技术点:

相关文章: