import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
- AF_INET refers to address family ipv4
- SOCK_STREAM meaning TCP protocol
- s = socket.socket()
- It simply creates a new socket using the given address family,socket type and protocol number.
- port = 12345
- Reserves a port for computer
- s.bind('',port)
- We binded our server to the specified port. Passing an empty string means that the server can listen to incoming connections from other computers as well. If we would have passed 127.0.0.1 then it would have listened to only those calls made within the local computer.
- s.listen(5)
- Server can connect to 5 clients, 6th or more clients are rejected.
- s.accept()
- Return new socket object c and address
- s.close()
- Marks the socket closed, all future operaions on socket will be failed.
#import library
import socket
s=socket.socket()
port=12345
s.bind('',port)
s.listen(5)
while True:
c,addr = s.accept()
data = c.recv(1024)
c.sendall(data)
c.close()
Server uses bind() , listen() , accept()
- First create socket object
- Give port number same as server
- connect() '127.0.0.1' local machine connection
- print s.recv(1024) #print data recv from socket
- close() connection
import socket
s=socketsocket()
port=12345
s.connect('127.0.0.1',port)
print s.recv(1024)
s.close()
%20Python/ReverseString.PNG)
Checkout My Article Socket Programming Multi-Threading At Geeksforgeeks
It helps us to connect a client to a server. Client is message sender and receiver and server is just a listener that works on data sent by client.
A thread is a light-weight process that does not require much memory overhead, they are cheaper than processes.
Multithreading is a process of executing multiple threads simultaneously in a single process.
A _thread module & threading module is used for multi-threading in python, these modules help in synchronization and provide a lock to a thread in use.
from _thread import *
import threading
A lock object is created by->
print_lock = threading.Lock()
A lock has two states, "locked" or "unlocked". It has two basic methods acquire() and release(). When the state is unlocked print_lock.acquire() is used to change state to locked and print_lock.release() is used to change state to unlock.
The function thread.start_new_thread() is used to start a new thread and return its identifier. The first argument is the function to call and its second argument is a tuple containing the positional list of arguments.
Let's study client-server multithreading socket programming by code-
Note:-The code works with python3.
# import socket programming library
import socket
# import thread module
from _thread import *
import threading
print_lock = threading.Lock()
# thread fuction
def threaded(c):
while True:
# data received from client
data = c.recv(1024)
if not data:
print('Bye')
# lock released on exit
print_lock.release()
break
# reverse the given string from client
data = data[::-1]
# send back reversed string to client
c.send(data)
# connection closed
c.close()
def Main():
host = ""
# reverse a port on your computer
# in our case it is 12345 but it
# can be anything
port = 12345
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
print("socket binded to post", port)
# put the socket into listening mode
s.listen(5)
print("socket is listening")
# a forever loop until client wants to exit
while True:
# establish connection with client
c, addr = s.accept()
# lock acquired by client
print_lock.acquire()
print('Connected to :', addr[0], ':', addr[1])
# Start a new thread and return its identifier
start_new_thread(threaded, (c,))
s.close()
if __name__ == '__main__':
Main()
Console Window:
socket binded to post 12345
socket is listening
Connected to : 127.0.0.1 : 11600
Bye
# Import socket module
import socket
def Main():
# local host IP '127.0.0.1'
host = '127.0.0.1'
# Define the port on which you want to connect
port = 12345
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# connect to server on local computer
s.connect((host,port))
# message you send to server
message = "shaurya says geeksforgeeks"
while True:
# message sent to server
s.send(message.encode('ascii'))
# messaga received from server
data = s.recv(1024)
# print the received message
# here it would be a reverse of sent message
print('Received from the server :',str(data.decode('ascii')))
# ask the client whether he wants to continue
ans = input('\nDo you want to continue(y/n) :')
if ans == 'y':
continue
else:
break
# close the connection
s.close()
if __name__ == '__main__':
Main()
Console Window:
Received from the server : skeegrofskeeg syas ayruahs
Do you want to continue(y/n) :y
Received from the server : skeegrofskeeg syas ayruahs
Do you want to continue(y/n) :n
Process finished with exit code 0
Reference->
https://docs.python.org/2/library/thread.html
Issues and Pull requests are most welcome.
Feel free to mail me for any queries.
