新秀篇 ##python中多线程,socket编程##
socket编程
网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket所谓socket通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过“套接字”向网络发出请求或应答网络请求socket起源于Uinx，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open–>读写write/read–>关闭close”模式来操作，socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作(读/写 IO，打开，关闭)Socket的英文原义是“孔”或“插座”。作为BSD UNIX的进程通信机制，取后一种意思。通常也称作”套接字”，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原义那样，像一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电,有的提供110伏交流电，有的则提供有线电视节目。 客户软件将插头插到不同编号的插座，就可以得到不同的服务
例如：中国移动客服
对于移动来说:一直监听一个号码10086，当有电话进来后，就分配一个客服和客户去沟通并处理请求
对于用户：需要知道10086这个号码，并需要打电话
Socket 是网络编程的一个抽象概念。通常我们用一个 Socket 表示
“打开了一个网络链接”,而打开一个 Socket 需要知道目标计算机的 IP
地址和端口号,再指定协议类型即可。
【客户端】:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
建立连接:
s.connect((‘127.0.0.1’, 9999))
接收欢迎消息:
print s.recv(1024)
for data in [‘Michael’, ‘Tracy’, ‘Sarah’]:
发送数据:
s.send(data)
print s.recv(1024)
s.send(‘exit’)
s.close()
import socket
#创建一个socket对象
client = socket.socket()
#创建连接
ip_port = ('127.0.0.1',9998)
client.connect(ip_port)
while True:
# 获取数据
data = client.recv(1024)
print data
# 发送数据
inp = raw_input('clent:')
client.send(inp)
if inp == 'exit':
break
【服务端】：
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
监听端口:
s.bind((‘127.0.0.1’, 9999))
s.listen(5)
print ‘Waiting for connection…’
while True:
接受一个新连接:
sock, addr = s.accept()
创建新线程来处理 TCP 连接:
t = threading.Thread(target=tcplink, args=(sock, addr))
t.start()
s.close()
print ‘Connection from %s:%s closed.’ % addr服务端操作
def tcplink(sock, addr):
print ‘Accept new connection from %s:%s…’ % addr
sock.send(‘Welcome!’)
while True:
data = sock.recv(1024)
time.sleep(1)
if data == ‘exit’ or not data:
break
sock.send(‘Hello, %s!’ % data)
import socket
#1.创建socket对象
sk = socket.socket()
#2.绑定端口和ip
ip_port = ('127.0.0.1',9998)
sk.bind(ip_port)
#3.最大连接数
sk.listen(5)
while True:
#获取客户端的ip和端口号
conn,address = sk.accept()
conn.send('hello')
flag = True
while flag:
data = conn.recv(1024)
print data
if data == 'exit':
flag = False
conn.send('sb')
conn.close()
【模拟实验】:
（1）在pythoncharm中执行服务端程序,模拟服务端开启
（2）在真机里找到当前客户端程序：
[kiosk@foundation39 day_07]$ cd socket
[kiosk@foundation39 socket]$ ls
client.py server.py
[kiosk@foundation39 socket]$ python client.py
基于python下的多线程
一.多线程的作用：
生产者消费者问题：（经典）
一直生产 一直消费 中间有阀值 避免供求关系不平衡
线程安全问题，要是线程同时来，听谁的
锁：一种数据结构 队列:先进线出 栈：先进后出
生产者消费者的优点(为什么经典的设计模式)
1.解耦（让程序各模块之间的关联性降到最低）
假设生产者和消费者是两个类，如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖(也就是耦合)，
如果将来消费者的代码发生变换，可能会影响到生产者，而如果两者都依赖于某个缓冲区，两者之间不直接依赖，
耦合也就相应降低了
生活中的例子：我们 邮筒 邮递员
举个例子，我们去邮局投递信件，如果不使用邮筒(也就是缓冲区)，你必须得把信直接交给邮递员，有同学会说，
直接交给邮递员不是挺简单的嘛，其实不简单，你必须得认识邮递员，才能把信给他(光凭身上的制服，万一有人假冒呢？？？)，
这就产成你和邮递员之间的依赖了(相当于生产者消费者强耦合)，万一哪天邮递员换人了，
你还要重新认识一下(相当于消费者变化导致修改生产者代码)，而邮筒相对来说比较固定，
你依赖它的成本就比较低(相当于和缓冲区之间的弱耦合)
2.支持并发
生产者消费者是两个独立的并发体，他们之间是用缓冲区作为桥梁连接，生
产者之需要往缓冲区里丢数据，就可以继续生产下一个数据，而消费者者只需要从缓冲区里拿数据即可，
这样就不会因为彼此速度而发生阻塞
接着上面的例子：如果我们不使用邮筒，我们就得在邮局等邮递员，直到他回来了，我
们才能把信给他，这期间我们啥也不能干(也就是产生阻塞)，或者邮递员挨家挨户的问(产生论寻)
3.支持忙闲不均
如果制造数据的速度时快时慢，缓冲区的好处就体现出来了，当数据制造快的时候，
消费者来不及处理，未处理的数据可以暂时存在缓冲区中，等生产者的速度慢下来，
消费者再慢慢处理
情人节信件太多了，邮递员一次处理不了，可以放在邮筒中，下次在来取
【实验】
（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()
（2）多线程处理：效率提高
from threading import Thread
from time import ctime, sleep
def music(a):
for i in range(2):
print 'I was listening to %s. %s' % (a, ctime())
sleep(2)
def movie(b):
for i in range(2):
print 'I was listening to %s. %s' % (b, ctime())
sleep(5)
t1 = Thread(target=music, args=('告白气球',))
t1.start()
t2 = Thread(target=movie, args=('泰坦尼克号',))
t2.start()
print 'all over %s' % ctime()
二.线程的定义：
线程是操作系统能够进行运算调度的最小单位（程序执行流的最小单元）
它被包括在进程之中，是进程的实际运作单位。一个进程可以并发多个线程
每条线程并行执行不同的任务
（线程是进程的一个实体，是被系统独立调度和分派的基本单元）
每一个进程启动时都会最先产生一个线程，即主线程
然后主线程会再创建其他的子线程
通常，我们写服务器处理模型的程序时，有以下几种模型：
(1)每收到一个请求，创建一个新的进程，来处理该请求；
(2)每收到一个请求，创建一个新的线程，来处理该请求；
(3)每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求
上面的几种方式，各有千秋：
第(1)中方法，由于创建新的进程的开销比较大，所以，会导致服务器性能比较差,但实现比较简单。
第(2)种方式，由于要涉及到线程的同步，有可能会面临死锁等问题。
第(3)种方式，在写应用程序代码时，逻辑比前面两种都复杂。
综合考虑各方面因素，一般普遍认为第(3)种方式是大多数网络服务器采用的方式
线程的缺点：
在UI编程中，常常要对鼠标点击进行相应，首先如何获得鼠标点击呢？
方式一：创建一个线程，该线程一直循环检测是否有鼠标点击，
那么这个方式有以下几个缺点：
CPU资源浪费，可能鼠标点击的频率非常小，但是扫描线程还是会一直循环检测，
这会造成很多的CPU资源浪费；如果扫描鼠标点击的接口是阻塞的呢？
如果是堵塞的，又会出现下面这样的问题，如果我们不但要扫描鼠标点击，
还要扫描键盘是否按下，由于扫描鼠标时被堵塞了，那么可能永远不会去扫描键盘；
如果一个循环需要扫描的设备非常多，这又会引来响应时间的问题；
所以，该方式是非常不好的。
『多线程01』
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'
『多线程02』：主线程不需要等待子线程啥时候结束就可以结束 但是会等到子线程结束之后一起销毁
from threading import Thread
import time
def Foo():
for item in range(100):
print item
time.sleep(1)
print 'before'
t1 = Thread(target=Foo)
【t1.setDaemon(True)
t1.start()
print 'after'
time.sleep(10)
『多线程03』加入了t1.join(5),表示主线程到join()就不往下走了，直到子线程进行完成
from threading import Thread
import time
def Foo():
for item in range(10):
print item
time.sleep(1)
print 'before'
t1 = Thread(target=Foo)
t1.start()
# 主线程到join()就不往下走了，直到子线程进行完成
t1.join(5)
# 这句代码意味着主线程主会等待子线程5秒之后就结束了，不管子线程是否完成
print 'after'
三.操作系统（生产者消费者问题）
1.这段代码没有交互,不是动态的
import threading
import Queue
import time
def Producer(name, que):
que.put('baozi')
print '%s:Made a baozi...' % name
def Consumer(name,que):
que.get()
print '%s:Got a baozi...' % name
# 创建队列
q = Queue.Queue()
p1 = threading.Thread(target=Producer, args=['chef1', q])
p2 = threading.Thread(target=Producer, args=['chef2', q])
p1.start()
p2.start()
c1 = threading.Thread(target=Consumer, args=['tom', q])
c2 = threading.Thread(target=Consumer, args=['harry', q])
c1.start()
c2.start()
2.操作系统升级版01：实现了动态化
import threading
import Queue
import time
import random
def Producer(name, que):
while True:
que.put('baozi')
print '%s:Made a baozi...' % name
time.sleep (random.randrange(3))
def Consumer(name, que):
while True:
que.get()
print '%s:Got a baozi...' % name
time.sleep(random.randrange(3))
# 创建队列
q = Queue.Queue()
p1 = threading.Thread(target=Producer, args=['chef1', q])
p2 = threading.Thread(target=Producer, args=['chef2', q])
p1.start()
p2.start()
c1 = threading.Thread(target=Consumer, args=['tom', q])
c2 = threading.Thread(target=Consumer, args=['harry', q])
c1.start()
c2.start()
3.操作系统升级版02版:实现智能化，生产者会合理的生产，消费者会等待，实现合理化
import threading
import Queue
import time
import random
def Producer(name,que):
while True:
if que.qsize() <3:
que.put('包子')
print '%s:Made a 包子..========' % name
else:
print '还有三个包子'
time.sleep(random.randrange(5))
def Consumer(name,que):
while True:
try:
que.get_nowait()
print '%s:Got a 包子..' % name
except Exception:
print '没有包子了'
time.sleep(random.randrange(4))
#创建队列
q = Queue.Queue()
p1 = threading.Thread(target=Producer,args=['chef1',q])
p2 = threading.Thread(target=Producer,args=['chef2',q])
p1.start()
p2.start()
c1 = threading.Thread(target=Consumer,args=['tom',q])
c2 = threading.Thread(target=Consumer,args=['harry',q])
c1.start()
c2.start()
4.异步的方式：模拟生活中作的事，“生产者和消费者有更加智能的交互”
import threading
import time
def Producer():
print 'chef:等人来买包子'
# 收到了消费者的event.set 也就是把这个flag改为了true,但是我们的包子并没有做好
event.wait()
# 此时应该将flag的值改回去
event.clear()
print 'chef:someone is coming for 包子'
print 'chef:making a 包子 for someone'
time.sleep(5)
# 告诉人家包子做好了
print '你的包子好了～'
event.set()
def Consumer():
print 'tom:去买包子'
# 告诉人家我来了
event.set()
time.sleep(2)
print 'tom:waiting for 包子 to be ready'
# 我在不断检测，但我已经不阻塞了
while True:
if event.is_set():
print 'Thanks~'
break
else:
print '怎么还没好呀～'
# 模拟正在做自己的事情
time.sleep(1)
event = threading.Event()
p1 = threading.Thread(target=Producer)
c1 = threading.Thread(target=Consumer)
p1.start()
c1.start()
四.事件驱动模型：
事件驱动编程是一种编程范式，这里程序的执行流由外部事件来决定。
它的特点是包含一个事件循环，当外部事件发生时使用回调机制来触发
相应的处理。另外两种常见的编程范式是(单线程)同步以及多线程编程。
目前大部分的UI编程都是事件驱动模型，如很多UI平台都会提供onClick()
事件，这个事件就代表鼠标按下事件。事件驱动模型大体思路如下：
1. 有一个事件(消息)队列；
2. 鼠标按下时，往这个队列中增加一个点击事件(消息)；
3. 有个循环，不断从队列取出事件，根据不同的事件，调用不同的函数，
如onClick()、onKeyDown()等；
4. 事件(消息)一般都各自保存各自的处理函数指针，这样，每个消息都有独立的处理函数；
5.事件驱动方式更智能化的让生产者和消费者交互
import threading
import time
def Producer():
print 'chef:等人来买包子'
#收到了消费者的event.set 也就是把这个flag改为了true,但是我们的包子并没有做好
event.wait()
#此时应该将flag的值改回去
event.clear()
print 'chef:someone is coming for 包子'
print 'chef:making a 包子 for someone'
time.sleep(5)
# 告诉人家包子做好了
print '你的包子好了～'
event.set()
def Consumer():
print 'tom:去买包子'
# 告诉人家我来了
event.set()
time.sleep(2)
print 'tom:waiting for 包子 to be ready'
event.wait()
print '哎呀～真好吃'
event = threading.Event()
p1 = threading.Thread(target=Producer)
c1 = threading.Thread(target=Consumer)
p1.start()
c1.start()
五.线程安全问题： 线程会出现异常无法输出正确的结果
线程安全（没有锁,执行出来的程序会乱）
"""
import threading
import time
num = 0
def run(n):
time.sleep(1)
global num
#线程锁
lock.acquire()
num +=1
print '%s\n' %num
lock.release()
lock = threading.Lock()
for i in range(1500):
t = threading.Thread(target=run,args=(i,))
t.start()
