死锁现象

死锁发生在当一个服务器和客户端同时试图往一个连接上写东西和同时从一个连接上读的时候。在这种情况下没有进程可以得到任何数据。

#!/usr/bin/env python
#-*- coding:utf-8 -*-
#测试锁死的情况
import socket, traceback

host = ‘‘        #主机设为空,程序就可以接收来自任何客户端的连接
port = 51422     #设置端口,选择一个任意大于1024的端口即可

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #创建socket对象,
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #把socket设置成可复用的
s.bind((host, port))     
s.listen(5)              

while True:
    try:  
        clientsock, clientaddr = s.accept()
    except KeyboardInterrupt:
        raise
    except:
        traceback.print_exc()
        continue
    
    try:
        print "Got connection from", clientsock.getpeername()
        while 1:
            data = clientsock.recv(4096)     #把在客户端写入的数据返回给客户
            if not len(data):
                break
            clientsock.sendall(data)
    except (KeyboardInterrupt, SystemExit):
        raise
    except:
        traceback.print_exc()

#close the connection
    try:
        clientsock.close()
    except KeyboardInterrupt:
        raise
    except:
        traceback.print_exc()
客户端测试:
[[email protected] one]# telnet localhost 51422
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is ‘^]‘.
wang
wang
wang
wang
tian
tian
xiang
xiang
shang
shang
hao
hao

客户端响应服务器的例子:

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import socket, sys
port = 51422
host = "localhost"
data = "x" * 10485760

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s = s.connect((host, port))

bytestwritten = 0
while bytestwritten <= len(data):
    startpos = bytestwritten
    endpos = min(bytestwritten + 1024 ,len(data))
    bytestwritten += s.send(data[startpos:endpos])    //感觉这点有一个问题
    sys.stdout.write("Wrote %d bytes\r" % bytestwritten)
    sys.stdout.flush()

s.shutdown()

print "All data sent"
while 1:
    buf = s.recv(1024)
    if not len(buf):
        break
    sys.stdout.write(buf)

启动服务器,接着运行响应服务器。服务器将显示有来自客户端的连接。客户端试图发送一个10Mb的数据,以1KB为单位传到服务器,接着它会取回结果。

10MB数据永远也传送不完。服务器会读取开始的4KB,试图在写完之后重复这个过程。因为客户端在发送完所有数据之前根本不进行任何的操作,操作系统的传输buffer在某一点上就会充满,两个进程就会在send()函数停滞。

时间: 2024-10-27 13:15:40

死锁现象的相关文章

Thking in Java---从哲学家就餐问题看死锁现象

我们知道一个对象可以有synchronized方法或其他形式的加锁机制来防止别的线程在互斥还没释放的时候就访问这个对象.而且我们知道线程是会变成阻塞状态的(挂起),所以有时候就会发生死锁的情况:某个任务在等待另一个任务,而后者又在等待其它任务,这样一直下去,知道这个链条下的任务又在等待第一个任务释放锁,这样就形成了一个任务之间相互等待的连续循环,没有任务可以继续的情况.死锁的最大问题在于它发生的几率非常小,并不是我们一运行程序它就死锁了,而是会不知道那个时候程序就死锁了并且我们很难重现当时出现死

死锁现象与解决方案,开启线程的2种方式,守护线程,线程VS进程,线程互斥锁,信号量

死锁现象与解决方案 from threading import Thread,Lock,active_count import time mutexA=Lock() # 锁1 mutexB=Lock() # 锁2 class Mythread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到A锁' %self.name) mutexB.acquire() print('%

同步函数死锁现象

多线程:一个进程中有多个线程可以同时执行任务 多线程的好处: 1.解决一个进程中可以同时执行多个任务的问题. 2.提高了资源利用率 多线程的弊端: 1.增加了CPU的负担 2.降低了一个进程中线程的执行概率 3.出现了线程安全问题 4.会引发死锁现象 自定义线程的实现方式: 方式一: 1.自定义一个类继承Thread类. 2.重写Thread类的run方法,把自定义线程的任务代码写在run方法上 3.创建Thread的子类对象,并且调用start方法启动一个线程 线程安全问题出现的根本原因: 1

死锁现象与递归锁

一 死锁现象 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread): def run(self): self.func1() self.f

python并发编程之线程(创建线程,锁(死锁现象,递归锁),GIL锁)

什么是线程 进程:资源分配单位 线程:cpu执行单位(实体),每一个py文件中就是一个进程,一个进程中至少有一个线程 线程的两种创建方式: 一 from multiprocessing import Process def f1(n): print(n,'号线程') if __name__ == '__main__': t1 = Thread(target=f1,args=(1,)) t1.start() print('主线程')  二 from threading import Thread

python 并发编程 多线程 死锁现象与递归锁

一 死锁现象 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 from threading import Thread from threading import Lock import time # 实例化两把不同的锁 mutexA = Lock() mutexB = Lock() class MyThread(Threa

2-7 死锁现象和递归锁

一 死锁现象 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁 from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread): def run(self): self.func1() self.f

Linux - 死锁现象

一.死锁的概念: 1.死锁的现象描述: 在很多应用中,需要一个进程排他性的访问若干种资源而不是一种.例如,两个进程准备分别将扫描的文档记录到CD上.进程A请求使用扫描仪, 并被授权使用.但进程B首先请求CD刻录机,也被授权使用.这时,A请求使用CD刻录机,但这个请求在B释放CD刻录机前会被拒绝.但是,进程B非但 不会释放CD刻录机,还去请求扫描仪.这时,两个进程僵持不下,都被阻塞,并一直处于这样的状态.这种状况就叫做死锁(deadlock). 2.死锁的规范定义: 如果一个进程集合中的每个进程都

操作系统中,进程的“死锁”现象

所谓死锁: 是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程. "死锁"产生的原因: 1.系统资源不足 2.进程运行推进的顺序不合适 3.资源分配不当 "死锁"产生的条件 1.互斥条件:一个进程每次只能被一个进程使用 2.请求与保持条件:一个进程因资源请求被阻塞时,对已获得的资源保持不放 3.不剥夺条件: 进程已获

python学习第37天GIL锁、死锁现象与递归锁、信号量、Event时间、线程queue

一.GIL锁 1. 什么是GIL全局解释器锁 定义: In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython's memory management is not thread-safe