osi7层模型及线程和进程

端口的作用：

　　在同一台电脑上，为了让不同 的程序分离开来！

http:网站默认端口是80

https:网站默认端口是443

osi七层模型：

1.应用层：软件

2.表示层：接收数据

3.会话：保持登录或链接状态

4.传输：tcp/udp

5.网络:IP

6.数据链路MAC

7.物理：把数据转化成电信号发送

TCP：的三次握手和四次挥手：

三次握手：客户端向服务端发起链接请求

四次挥手：客户端和服务端断开链接

线程和进程：

1.操作系统/应用程序:

　　a.硬件：硬盘，CPU，主板，显卡，内存条，内存、、、、

　　b.系统：就是软件，控制计算机的硬件，让他们相互配合。

　　c.软件：安装一些功能

2.操作中的并发：

　　并发（伪）：由于执行速度特别快，人感觉不到停顿

　　并行（真）：创建多个人同时操作某个功能。

3.其他语言的线程/进程

　　单进程，单线程的应用程序：egg：print('666')

　　什么是线程，什么是进程？

　　线程：

　　　　工作的最小的单元，共享进程中的所有资源，每个线程可以分担一些任务，最终能够完成结果。

　　进程：

　　　　独立开辟的内存，进行数据之间的隔离

　　一个用应用程序（软件），可以有多个进程，（默认只有一个），一个进程中可以有多个线程（默认一个）

线程的使用：

　　1.基本使用

import  threading
def func(arg):
    print(arg)
t=threading.Thread(target=func,args=(11,))
t.start()
11

　　2.主线程默认等子线程执行完毕

import time
def func(arg):
    time.sleep(arg)
    print(arg)

t1 = threading.Thread(target=func,args=(3,))
t1.start()

t2 = threading.Thread(target=func,args=(9,))
t2.start()

print(123)
#
3
9
先执行主线程，在执行子线程，主线程等子线程执行完毕才结束程序

　　3.主线程不再等子线程，主线程终止，所有子线程终止

import threading
import time
def func(arg):
    time.sleep(2)
    print(arg)
t1=threading.Thread(target=func,args=(3,))
t1.setDaemon(True)
t1.start()
t2=threading.Thread(target=func,args=(3,))
t2.setDaemon(True)
t2.start()
print(123)
#123
#引入sys模块的setDaemon方法，让主线程不再等待子线程。

　　4.开发者可以人为的控制让主线程等待子线程（最多等待的时间）

import time
import threading
def func(arg):

    time.sleep(0.01)#根据时间的长短，执行结果会不同
    print(arg)
print("创建子线程t1")
t1=threading.Thread(target=func,args=(3,))
t1.start()
t1.join(2)
#join有参数的话，让主线程最多等n秒，无论n秒后是否执行完毕，都会往下执行
#join没有参数的话，让主线程一直等着，等t1(子线程)执行完后，才会继续往下执行
print('创建子线程t2')
t2=threading.Thread(target=func,args=(9,))
t2.start()
t2.join(2)
print(123)
#创建子线程t1
3
创建子线程t2
9
123

　　5.线程名称

import threading
def func(arg):
    t = threading.current_thread()#获取当前执行该函数的线程对象
    name=t.getName()#根据当前的线程对象获取当前的线程名称
    print(name,arg)
t1=threading.Thread(target=func,args=(11,))
t1.setName('Jave yang')
t1.start()
#Jave yang 11

　　6.线程本质

# 先打印：11？123？
def func(arg):
    print(arg)

t1 = threading.Thread(target=func,args=(11,))
t1.start()
# start 是开始运行线程吗？不是
# start 告诉cpu，我已经准备就绪，你可以调度我了。
print(123)

　　7.面向对象版本的多线程

class MyThread(threading.Thread):

    def run(self):
        print(11111,self._args,self._kwargs)

t1 = MyThread(args=(11,))
t1.start()

t2 = MyThread(args=(22,))
t2.start()
print('end')

11111 (11,) {}
11111 (22,) {}
end

4.python中线程和进程（GIL锁）

为什么会有GIL锁：python创始人在开发这门语言时，目的快速把语言开发出来，加上锁，切换时按照100条字节指令来进行线程之间切换。

GIL锁：全局解释器锁，用于限制一个进程同一时刻只有一个线程能被CPU调用。

扩展：默认GIL锁在执行100个CPU指令后，才会切换　　　　使用sys模块查看sys.getchekinterval

lock=threading.Rlock()

lock.acquire()加锁，表示在此区域同一时刻只能有一个线程执行

lock.release()释放锁

import time
import threading

lock = threading.RLock()

n = 10

def task(i):
    print('这段代码不加锁',i)

    lock.acquire() # 加锁，此区域的代码同一时刻只能有一个线程执行
    global n
    print('当前线程',i,'读取到的n值为：',n)
    n = i
    time.sleep(1)
    print('当前线程',i,'修改n值为：',n)
    lock.release() # 释放锁

for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

总结：1.操作系统帮开发者操作硬件

　　   2.程序员写好代码在操作系统上运行（依赖解释器）

　　   3.python多线程情况下，计算密集型操作，效率低！（GIL），IO操作，效率高！

　　　python多进程情况下，计算密集型操作，效率高（浪费资源），IO操作，效率高（浪费资源）

　　   4.Java多线程情况下，计算密集型操作，效率高！，IO操作，效率高！

　　　Java多进程情况下，计算密集型操作，效率高（浪费资源），IO操作，效率高（浪费资源）

总结：

1.应用程序/进程/线程的关系***********************（面试）

为了使应用程序能够运行，创建了进程帮助程序之间进行隔离，为线程的工作提供了工作环境，线程帮助完成程序的操作！

2.为什么要创建线程？（提供工作）

　　线程是CPU工作的最小单元，创建线程可以利用多核优势实现操作（Java、c#）

3.为什么要创建进程（提供工作的环境）：   进程和进程之间做数据隔离（Java、c#）

4.python

　　a.  python中的GIL锁造成多线程无法利用多核优势，用进程来处理（浪费资源）

　　b.  线程的创建：

　　c.  join  ：人为的控制让主线程等待子线程

　　　join有值时，让主线程等子线程n秒，如果n秒后子线程还没有执行完，就继续执行下面的代码，只等n秒

　　　join没有值得时候，让主线程等到子线程执行完之后才会执行后面的代码

　　d.  setdeamon 引入sys模块的setDaemon方法，让主线程不再等待子线程。主线程执行完毕，子线程必须要执行完毕，没有执行完就不管了

e.  threading .current_thread()获取到执行当前函数的线程对象，.getName()#根据当前的线程对象获取当前的线程名称

　　f:获取线程的id

　　.  锁，获得锁，释放锁

5.python 线程编写+锁

6.小爬虫