草稿，未完待续：
json.dumps 序列化（将数据变成字符串格式）
head_json.encode('utf-8') 将字符串编译成bytes格式。
struct提供用format specifier方式对数据进行打包和解包（将数字转成固定长度的bytes格式）
套接字只能发送bytes格式的数据
只有字符能编码成bytes格式，数字等其它类型的数据不能编码成bytes格式。
进程、线程
Socket实现并发
Self.Request就是conn；
import socketserver
#Ftpserver(conn, client_addr, obj)
class FTPserver(socketserver.BaseRequestHandler):
#通讯 #必须创建一个类，必须继承这个方法（固定死的）
def handle(self): #必须创建handle这个函数（固定死的）
print('=-=====>',self.request)
print(self.request)
while True:
data=self.request.recv(1024)
print(data)
self.request.send(data.upper())
if __name__ == '__main__':
obj=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FTPserver) #创建线程,一个线程就是一个服务员，多线程就是多个服务员。
print(obj.server_address)
print(obj.RequestHandlerClass)
print(obj.socket)
obj.serve_forever() #链接循环
实现多线程
开启一个子线程：使用threading模块
并行：多进程同时运行，不需要切换
并发：多进程之间切换运行，切换调节：
#子线程继承父线程的setDaemon的状态，主（注意不是父）线程默认为false；true为守护线程，false为非守护线程。主线程执行结束会强行关闭守护线程，需要等待非守护线程执行完才结束。
#IO操作不占用CPU，并且遇到IO操作直接执行其他线程。GIL锁规定单一进程只能实现并发，不能实现并行。结合以上两个原因得出结论：多线程对IO密集型任务有优势，对计算密集型任务没有优势。
创建线程1
import threading
import time
def foo(n):
time.sleep(n)
print("foo....%s" % n)
print(threading.activeCount()) #总共有多少个线程
def bar(n):
time.sleep(n)
print("bar......%s" % n)
s=time.time()
t1=threading.Thread(target=foo,args=(2,)) #创建线程对象,args=(线程数,)
#t1.setDaemon(True) #设置为守护线程
t1.start() #开启线程
t2=threading.Thread(target=bar,args=(5,))
#t2.setDaemon(True)
t2.start()
t1.join() # 阻塞主线程
t2.join()
print("++++++",threading.activeCount())
print("ending!")
print("cost time:",time.time()-s)
# foo(4)
# bar(5)
创建线程2
创建10个线程
进程：由程序、数据集、进程控制块三部分组成。
线程是最小的执行单元。
进程是最小的资源管理单元，进程是在一个数据集上正在运行的程序。管理着数据集和线程。
进程和线程的关系：
（1） 一个线程只能属于一个进程，一个进程至少有一个或多个线程。
（2） 资源分配给进程，同一进程的所有线程共享该进程的所有资源。
（3） 操作系统把CPU分给线程，即真正在CPU上运行的是线程。
进程和线程切换的原则：
1、时间片（非常短的时间）
2、遇到IO操作（sleep，input，accept）[不占用CPU]就切换。
3、优先级切换，优先切换到优先级高的。
创建子线程：
对象名=Threading.Thread(target=函数,args=(线程数,)
对象名.start() #开启子线程。
join函数：子线程调用不结束，下面的代码不执行
守护进程：守护线程和主线程共进退，等待非守护线程执行完退出
子线程继承父线程是否是守护线程的特征。也就是说如果父线程是守护线程，那么子线程也是守护线程。。。
多线程比较适合IO密集型，如果用于计算密集型反而会降低效率。
同步：进程在执行某个请求时，一直等待返回数据之后才执行下面的代码。
异步：异步双方不需要共同的时钟，不阻塞当前线程，允许后续操作。（全程无阻塞）
总结了一句话不知道对不对：IO密集型任务就是异步。
Python中函数，类和模块有自己的名称空间。
互斥锁：
多线程处理相同数据源的数据时，如果有IO会出现阻塞和切换，从而导致计算结果不准确。
保证共享数据操作的完整性。每个对象都对应一个"互斥锁" ，保证只能有一个线程访问该对象。
互斥锁只加到处理数据的代码上。
互斥锁的创建：
|
import threading
R=threading.Lock()
R.acquire() ''' 对公共数据的操作 ''' R.release() |
import threading
import time
def sub():
global num # 掌握为什么加global num
lock.acquire() #获取锁
temp=num
time.sleep(0.1 )
num=temp-1
lock.release() #释放锁
time.sleep(2)
num=100
l=[]
lock=threading.Lock() #创建互斥锁对象
for i in range(100):
t=threading.Thread(target=sub,args=())
t.start()
l.append(t)
for t in l:
t.join()
print(num)
互斥锁的讲解：
多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。
考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。
锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
实例：
#!/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
退出主线程
死锁：
两把锁互相等待对方释放，