2023年分布式系统实验报告

中南大学

分布式系统实验报告

目录

（我选做4题，按住Ctrl点击目录条可直达,wps下有效）

实验一数据包socket应用...................................错误!未定义书签。

一、实验目的。错误!未定义书签。

二、预习与实验规定.........................................错误!未定义书签。

三、实验环境。错误!未定义书签。

四、实验原理。错误!未定义书签。

五、实验内容。错误!未定义书签。

六、实验报告...............................................错误!未定义书签。

七、思考题.................................................错误!未定义书签。

实验二流式socket应用。错误!未定义书签。

一、实验目的。错误!未定义书签。

二、预习与实验规定.........................................错误!未定义书签。

三、实验环境...............................................................11

四、实验原理。错误!未定义书签。

五、实验内容。错误!未定义书签。

六、实验报告...............................................................13

七、思考题.................................................错误!未定义书签。

实验三客户/服务器应用开发..................................错误!未定义书签。

一、实验目的。错误!未定义书签。

二、预习与实验规定。错误!未定义书签。

三、实验环境...............................................错误!未定义书签。

四、实验原理。错误!未定义书签。

五、实验内容................................................错误!未定义书签。

六、实验报告。错误!未定义书签。

实验九虚拟机的使用与Linux系统的安装......................错误!未定义书签。

一、实验目的错误!未定义书签。

二、实验内容和环节错误!未定义书签。

三、实验结果。错误!未定义书签。

实验一数据包socket应用

一、实验目的

1.理解数据包socket的应用

2.实现数据包socket通信

3.了解Java并行编程的基本方法

二、预习与实验规定

1.预习实验指导书及教材的有关内容，了解数据包socket的通信原理；

2.熟悉一种javaIDE和程序开发过程；

3.了解下列JavaAPI:Thread>Runnable；

4.尽也许独立思考并完毕实验。

三、实验环境

a)独立计算机或计算机网络；

b)Windows操作系统。

c)Jdk工具包

d)JCreatororothers

四、实验原理

1.分布式计算的核心是进程通信。

操作系统、网卡驱动程序等应用从不同抽象层面提供了对进程通信的支持，例如

Winsock、.*。SocketAPI是一种作为IPC提供对系统低层抽象的机制。尽管

应用人

员很少需要在该层编写代码，但理解socketAPI非常重要，由于：1,高层设施是构建于s

ocket

API之上的，即他们是运用socketAPI提供的操作来实现；2,对于以响应时间规定

较高或

运营于有限资源平台上的应用来说，socketAPI也许是最适合的。

在Internet网络协议体系结构中，传输层上有UDP和TCP两种重要协议,UDP允许在

传送层使用无连接通信传送，被传输报文称为数据包。（是否存在面向连接的数据包

socket?）因此数据包socket是基于UDP的不可靠IPC。Java为数据包socketAP

I提供两个类：

⑴针对socket的datagramSocket类

⑵针对数据包互换的datagramPacket类

希望使用该API发送和接受数据的进程须实例化一个datagramSocket对象，每个

socekt

被绑定到该进程所在及其的某个UDP端口上。为了向其他进程发送数据包，进程必须创建

一个代表数据包自身的对象。该对象通过实例化一个datagramsoeket对象创建。

在接受者进程中，datagramPacket对象也必须被实例化并绑定到一个本地端口上，该端

口必须与发送者数据包的定义一致。接受进程创建一个指向字节数组的DatagramPacket,

并

调用datagramSocket对象的receive方法，将DatagramPacket对象指针作为参数

定义。

2.并行编程（以Java为例1）

一个线程是比进程更小的执行粒度。Java虚拟机允许应用程序有多个执行线程同时运

行。有两种方法来创建一个新线程的执行。一个是声明一个类是一个线程的子类。这个子类

应重写Thread类的run方法。一个子类的实例可以被分派和启动。另一种方法创建一

个线

程，并同时声明一个类实现了Runnable接口（这个类要实现run方法）。一个类的实例

可以

被分派并作为参数传递给创建的线程，并启动线程。例如:

创建一个类是Thread的子类：

classSomeThreadextendsThread{

SomeThread(){

)

pub1icvoidrun(){

)

)

SomeThreadp=newSomeThread();

p.start();

创建一个实现RunnabIe接口的类并传递给线程：

classSomeRunimplementsRunnable{

SomeRun(){

)

publicvoidrun(){

SomeRunp=newSomeRun(143);

newThread(p).start();

当一个实现Runnable接口的类被执行时，可以没有子类。实例化一个Thread实例，并

通过自身作为目的线程。在大多数情况下，假如你只打算重写的run()方法,并没有其它的

线程方法,应使用Runnable接口。由于类不应当被继承，除非程序员故意修改或增强类

的基本行为。

五、实验内容

1.构建客户端程序

(1)构建datagramSocket对象实例

(2)构建DatagramPacket对象实例，并包含接受者主机地址、接受端标语等信息

(3)调用datagramSocket对象实例的send方法，将DatagramPacket对象实

例作为参

数发送。

2.构建服务器端程序

(1)构建datagramSoeket对象实例,指定接受的端标语。

(2)构建DatagramPacket对象实例，用于重组接受到的消息。

(3)调用datagramSocket对象实例大家receive方法，进行消息接受，并将

DatagramPacket对象实例作为参数。

六、实验报告

1.客户端和服务器端程序的伪代码；

客户端：

importjava.io.IOException;

.DatagramPacket;

.DatagramSocket;

.lnetAddress；

importjava.utiI.Scanner;

publicclassC1ient(

pub1icstaticvoidmain(String[]args)throwsIOException

//创建一个客户端DatagramSocket,使用随机端口

DatagramSocketsocket=newDatagramSocket();

//初始化发送用的DatagramSocket,它包含一个长度为0的字节数组

DatagramPacketoutPacket=newDatagramPacket(newbyte[0],0

,InetAddress.getByName(nM,30000);

//定义接受网络数据的字节数组

byte[]inBuff=newbyte[4096]；

DatagramPacketinPacket=newDatagramPacket(inBuff,in

Buff.length)；

//创建键盘输入流

Scannersean=newScanner(System.in);

//不断地读取键盘输入

while(scan.hasNextLine())

(

//将键盘输入的一行字符串转换成字节数组

byte[]buff=scan.nextLine().getBytes();

//设立发送用的DatagramPaeket中的字节数据

outPacket.setData(buff);

//发送数据报

socket.send(outPacket);

//读取Socket中的数据，读到的数据放在inPacket所封装的字节数组

中

socket.receive(inPacket);

System.out.printin(newString(inBuff,0,inPacket.getLength

()))：

)

)

服务端:

importjavaJo.I0Exception;

.DatagramPacket;

.DatagramSocket；

publicc1assServices{

publicstaticvoidmain(String[]args)throwsIOException

0{

。//定义接受网络数据的字节数组

。。byte[]inBuff=newbyte[4096];

。//仓U建DatagramSocket对象

DatagramSocketsocket=newDatagramSocket(30000)；

//以指定字节数组创建准备接受数据的DatagramPacket对象

DatagramPacketinPacket=newDatagramPacket(inBuff,

inBuff.Iength);

Stringmessage="消息已经收到!”;

while(true){

®socket.receive(inPacket)；

。//将接受到的内容转换成字符串后输出

System.out.println(newString(inBuff,0,inP

acket.getLength()));

//从字符串数组中取出一个元素作为发送数据

byte[]sendData=message.getBytes()；

//以指定的字节数组作为发送数据,以刚接受到的Datag

ramPacket的

//源SocketAddress作为目的SocketAddress创建Datagram

Paeket

//定义一个用于发送的DatagramPacket对象

DatagramPacketoutPacket=newDatagramPacket(sen

dData

,sendData.length,inPacket.getSocketAddress());

//发送数据

socket.send(outPacket)；

}

)

}

2.实验过程中的问题和解决途径；

问题:对于DatagramPacketsDatagramSocket不怎么了解

解决途径：查阅JDKapi文档

3.实验结果：

服务端：

日控制台S3宓砧融单屏>|已里▼口yoi

Services[JavaC:\ProgramFiles\JavaVdkL8Q_101AbiNavaw.exe(2017年4月11.且上刊12e设)

hello,nihao

kaiwanxiao

客户端1：

日控制台汉_______________________________■一一|A砧岸回回IYI□▼亡j▼=U

Client[Java£5^隹字]C:\ProgramFtles\Java>jdkl.8.0_101\bin\javaw.exe(2017^4^116上午11:29:38)

hello,nihaoIqient[Java靖眄C:\programFiles\Java\idkL8.0」01\bin\iavaw.exe(2017a月11日上午11:

惆息已经收到！

客户端2：

日拄制台汉|，___________aim砧各超国I色里▼亡！▼口e

Client[Java封C:\ProgramKles\Java\jdkl.8.0_101\bin\javaw.exe(20170月11日上午11:30:00)

kaiwanxiao

情息已经收到！

七、思考题

1.如何避免数据包丢失而导致的无限等待问题？

答:我认为可在发包时设定一个定期器，若发出去的包在一定期间内没有收到答应，则再发一

次。为了避免接受者接到反复的包，可以给数据包加个序号，接受者收包时查看序号即可。

2.如何实现全双工的数据包通信？

答:运用端口套接字之间的通信功能。

实验二流式socket应用

一、实验目的

1.理解流式socket的原理

2.实现流式socket通信

二、预习与实验规定

1.预习实验指导书及教材的有关内容，了解流式socket的通信原理；

2.熟悉java环境和程序开发过程；

3.尽也许独立思考并完毕实验。

三、实验环境

a)独立计算机;

b)Windows操作系统；

c)Jdk工具包

四、实验原理

SocketAPI是一种作为IPC提供低层抽象的机制。尽管应用人员很少需要在该层编写

代

码,但理解s。cketAPI非常重要，由于:1,高层设施是构建于socketAPI之上的，即他

们

是运用socketAPI提供的操作来实现;2,对于以响应时间规定较高或运营于有限资源平

台

上的应用来说，socketAPI也许是最适合的。

在Internet网络协议体系结构中，传输层上有UDP和TCP两种重要协议，UDP允许使

用无连接通信传送，被传输报文称为数据包。而TCP则允许面向连接的可靠通信，这种

IPC

称为流式socketoJava为流式socketAPI提供两类socket⑴式用于连接的连接

socket(2)式用于数据互换的数据socketo

五、实验内容

1.构建客户端程序和服务器端程序都需要的MystreamSocket类，定义继承自jav

aSocket

的sendMessage和receiveMessage方法

2.构建客户端程序

(1)创建一个MyStreamsocket的实例对象，并将其指定接受服务器和端标语

(2)调用该socket的receiveMessage方法读取从服务器端获得的消息

3.构建服务器端程序

(1)构建连接socket实例，并与指定的端标语绑定，该连接socket随时侦听客户

端的连接请求

(2)创建一个MyStreamsocket的实例对象

(3)调用MyStreamsocket的实例对象的sendMessage方法，进行消息反馈。

六、实验报告

1.应用程序的结构图，说明程序之间的关系;

Asencruse*socket%:oneforacceptingconnection、,anotherforscn(Vreceive

2.程序的伪代码。

公用月艮务功能MystreamSoeket.java：

.*；

importjava.io.*;

publicclassMystreamSocketextendsSocket{

privateSocketsocket;

privateBufferedReaderinput;

privatePrintWriteroutput；

//客户端的构造方法

MystreamSocket(InetAddressacceptorHost,

intacceptorPort)throwsSocketException,IOException{

socket=newSocket(acceptorHost,acceptorPort)；

setStreams();

)

//服务端的构造方法

MystreamSocket(Socketsocket)throwsIOException{

this.socket=socket；

setStreams();

}

//设立输出输入流

privatevoidsetStreams()throwsIOException{

InputStreaminStream=socket.getlnputStream();

input=newBufferedReader(newInputStreamReader(inStream));

0utputStreamoutStream=socket.getOutputStream()；

output=newPrintWriter(newOutputStreamWriter(outStream));

)

//发送消息

pub1icvoidsendMessage(Stringmessage)throwslOException{

output.println(message);

output.f1ush()；

}

//接受消息

pub1icStringreceiveMessage()throwsIOException{

Stringmessage=input.readLine();

returnmessage;

)

//关闭所有打开的东西

publicvoidc1oseAII(){

try(

if(input!=null)input.close();

。。if(output!=null)output.close()；

0。if(socket!=nu1I)socket.close()；

}catch(I0Exceptione){

o。//TODO自动生成的catch块

6e.printStackTrace()；

)

)

)

客户端C1lent.java：

importjava.io.10Exception；

.lnetAddress;

publieclassClient{

publicstaticvoidmain(Stringargs[]){

。。try{

o。InetAddresshostname=lnetAddress.getByName(Hlocalhost");

。。。MystreamSocketmss=newMystreamSocket(hostname,12345)；

。。mss.sendMessage("我是客户端,我请求连接!”)；

。®Systern.out.print1n(mss.receiveMessage());

s。mss.cIose();

。。}catch(10Exceptione){

//TODO自动生成的catch块

se.printStackTrace();

°}

服务端Services.java：

importjava.io.lOException;

.ServerSocket;

.Socket；

pub1icclassServices{

。pub1icstaticvoidmain(Stringargs[]){

。。try(

ServerSocketservices=newServerSocket(12345)；

。。。Socketsocket;

while(true){

〃监听端口看是否有连接请求

。socket=services.accept()；

。。。〃多线程解决连接请求

/onewServicesThread(socket).start();

00J

}catch(IOExceptione){

//TODO自动生成的catch块

o。e.printstackTrace();

服务端多线程实现ServicesThread.java：

importjava.io.lOException;

.Socket；

publicclassServicesThreadextendsThread{

Socketsoeket；

。ServicesThread(Socketsocket){

othis.socket=socket;

)

pub1icvoidrun(){

。try(

。。MystreamSocketmss=newMystreamSocket(socket)；

。。System.out.println(mss.receiveMessage());

»mss.sendMessage("消息己收到!”卜

。。mss.closeAl1();

o}catch(10Exceptione){

。TODO自动生成的catch块

—e.printStackTrace();

°}

七、思考题

1.如何实现全双工的流式socket通信？

答：服务端监听端口，每当有一个连接请求发来时，就与其建立新的连接，然后运用其提供

的功能进行通信。

2.如何实现安全socketAPI?

答:注旨在通信过程中的各种异常情况的捕获与解决。

3.如何实现1对多的并发？

答：在服务端使用多线程。

实验三客户/服务器应用开发

一、实验目的

1.验证daytime和echo程序，

2.实现包socket支撑的C/S模式IPC机制

3.实现流式socket支撑的C/S模式IPC机制

二、预习与实验规定

1.预习实验指导书及教材的有关内容，了解daytime和echo要提供的具体服务内容;

2.复习包socket和流式socket的实现原理；

3.实验前认真听讲，服从安排。尽也许独立思考并完毕实验。

三、实验环境

a)独立计算机;

b)Windows操作系统。

c)Jdk工具包

四、实验原理

C/S模式是重要的分布式应用范型，其设计的目的是提供网络服务。网络服务指如

daytime、telnet>ftp和WWW之类的允许网络用户共享资源的服务。要构建C/

S范型的应用就必须解决以下一些关键问题:

(1)如何通过会话实现多个用户的并发问题

(2)如何定义客户和服务器在服务会话期间必须遵守的协议

(3)服务定位问题

⑷进程间通信和事件同步问题:语法、语义和响应

(5)数据表达问题

在解决了这些问题的基础上,C/S范型必须遵从3层结构的软件体系结构：

(1)表达层，提供与客户端进行交互的界面

(2)应用逻辑层，定义服务器和客户端要解决的重要事务的业务逻辑

(3)服务层，定义应用逻辑层所需要的底层支持技术，例如定义其IPC机制里的

receive方法和send方法等。

五、实验内容

L构建用数据包socket实现的daytime客户端程序

(1)构建表达层程序DaytimeC1ient1.java

⑵构建应用逻辑层程序DaytimeHelper1.java

(3)构建服务层程序MyC1ientDatagramSocket.java

2.构建用数据包socket实现的daytime服务器端程序

(1)构建表达层和应用逻辑层程序DaytimeServerl.java

(2)构建服务层程序MyServerDatagramSocket.java

⑶构建服务层程序MyServerDatagramSocket.java所需要的下层

程序

DatagramMessage.java(它封装了客户端的消息和地址)

3.构建用流式socket实现的daytime应用程序包

4.构建用数据包socket实现的echo应用程序包

5.构建用流式socket实现的echo应用程序包

六、实验报告

1.用数据包Socket实现的daytime应用程序包的构架，列明各程序之间的关系;

客户端:

服务端:

代码:

客户端:

DaytimeClientl.java

importjava.io.*;

publicclassDaytimeClientl{

publicstaticvoidmain(String[]args){

InputStreamReaderis=newInputStreamReader(System.in)；

BufferedReaderbr=newBufferedReader(is);

try(

System.out.printIn("WeIcometotheDaytimeclient.、n”+

nWhatisthenameoftheserverhostH);

StringhostName=br.readLine();

if(hostName.length()==0)

hostName="Iocalhost";//使用默认主机名

System.out.println("Whatistheportnumberoftheserverhos

tM)；

StringportNum=br.readLine();

if(portNum.Iength()==0)

portNum="1300";//设立默认端口

System.out.println(nHereisthetimestampreceivedfromtheserve

rH

+DaytimeClientHelper1.getTimestamp(hostName,portNum));

)

catch(Exceptionex){

ex.printStackTrace()；

}

)

DaytimeCIientHeiper1.java

.*;

publicclassDaytimeC1ientHelperl{

pub1icstaticStringgetTimestamp(StringhostName,StringportN

um)(

Stringtimestamp=

try(

InetAddressserverHost=InetAddress.getByName(hostName)；

intserverPort=Integer.parselnt(portNum);

//实例化socket发送和接受数据

MyDatagramSocketmySocket=newMyDatagramSocket()；

mySocket.sendMessage(serverHost,serverPort,"");

timestamp=mySocket.receiveMessage();//时间戳

mySocket.close()；

}

catch(Exceptionex){

System.out.print1n("Thereisaproblem："+ex);

}

returntimestamp;

MyCIientDatagramSocket.java

.*;

importjava.io.*；

publicclassMyClientDatagramSocketextendsDatagramSocket{

staticfina1intMAX_LEN=100;

MyCIientDatagramSocket()throwsSocketException{

super();

}

MyClientDatagramSoeket(intportNo)throwsSocketException{

super(portNo);

)

publicvoidsendMessage(InetAddressreceiverHost,intreceiverPo

rt,Stringmessage)

throwslOException{

byte[]sendBuffer=message,getBytes();

DatagramPacketdatagram=newDatagramPacket(sendBuffer,send

Buffer.length,

receiverHost,receiverPort);

this.send(datagram);

)

publicStringreceiveMessage()

throwsIOException{

byte[]receiveBuffer=newbyte[MAX_LEN]；

DatagramPacketdatagram=newDatagramPacket(receiveBuffei;M

AX_LEN);

this.receive(datagram)；

Stringmessage=newString(receiveBuffer);

returnmessage；

服务端:

DaytimeServer1.java

importjava.io.*；

importjava,utiI.Date；

publieclassDaytimeServerl{

publiestaticvoidmain(String[]args){

intserverPort=13;

if(args.length==1)

serverPort=Integer.parseInt(args[0])；

try(

MyServerDatagramSocketmySocket=newMyServerDatagramSocke

t(serverPort)；

System.out.println("Daytimeserverready.")；

whi1e(true){

DatagramMessagerequest=mySocket.receiveMessageAndSe

nder()；

System.out.print1n(nRequestreceived");

Datetimestamp=newDate()；

System.out.print1n("timestampsent："+timestamp.toString())；

mySocket.sendMessage(request.getAddress(),

request.getPort(),timestamp.toString());

)

}

catch(Exceptionex){

Systern,out.println("Thereisaproblem:"+ex)；

}

)

)

MyServerDatagramSoeket.java

importjava,net.*;

importjava.io.*;

pub1icclassMyServerDatagramSocketextendsDatagramsocket{

staticfina1intMAX_LEN=100;

MyServerDatagramSocket(intportNo)throwsSocketException{

super(portNo)；

)

publicvoidsendMessage(lnetAddressreceiverHost,intreceiverPort,

Stringmessage)

throwsIOException{

byte[]sendBuffer=message.getBytes()；

DatagramPacketdatagram=

newDatagramPacket(sendBuffer,sendBuffer.length,receiverHost,

receiverPort)；

this.send(datagram)；

)

publicStringreceiveMessage()

throwsIOException{

byteE]receiveBuffer=newbyte[MAX_LEN];

DatagramPacketdatagram=newDatagramPacket(receiveBuffer;MAX_LEN);

this.receive(datagram);

Stringmessage=newString(receiveBuffer)；

returnmessage;

)

pub1icDatagramMessagereceiveMessageAndSender()

throwslOException{

byte[]receiveBuffer=newbyte[MAX_LEN];

DatagramPacketdatagram=newDatagramPacket(receiveBuffer,MAX.

LEN);

this.receive(datagram);

DatagramMessagereturnVal=newDatagramMessage();

returnVai.putVal(newString(receiveBuffer),datagram.getAddress(),

datagram.getPort())；

returnreturnVa1;

}}

DatagramMessage.java

pub1icclassDatagramMessage{

privateStringmessage；

privateInetAddresssenderAddress;

privateintsenderPort;

publicvoidputVal(Stringmessage,InetAddressaddr,intport){

this,message=message;

this.senderAddress=addr;

this,senderPort=port;

pub1icStringgetMessage(){

returnthis,message；

)

publicInetAddressgetAddress()

returnthis.senderAddress;

)

publicintgetPort(){

returnthis.senderPort;

}

2.用流式socket实现的daytime应用程序包的构架，列明各程序之间的关系;

客户端：

服务端:

共有的:

MyStreamSocket.java

.*;

importjava.io.*;

pub1icc1assMyStreamSocketextendsSocket{

privateSocketsocket；

privateBufferedReaderinput；

privatePrintWriteroutput;

MyStreamSocket(InetAddressacceptorHost,

intacceptorPort)throwsSocketException,IOExcep

tion{

socket=newSocket(acceptorHost,acceptorPort)；

setStreams()；

)

MyStreamSocket(Socketsocket)throwslOException{

this.socket=socket；

setStreams()；

)

privatevoidsetStreams()throwslOException{

InputStreaminStream=socket.getlnputStream();

input=newBufferedReader(newInputStreamReader(inSt

ream));

OutputStrearnoutStream=socket.getOutputStream()；

output=newPrintWriter(new0utputStreamWriter(outStre

am));

}

publicvoidsendMessage(Stringmessage)throwsIOException{

output.print1n(message);

output.flush();

)

publieStringreceiveMessage()throwsIOException{

Stringmessage=input.readLine()；

returnmessage;

)

}

客户端：

DaytimeClient2.java

importjava.io.*;

publicc1assDaytimeClient2{

pub1icstaticvoidmain(String[]args)

InputStreamReaderis=newInputStreamReader(System.in);

BufferedReaderbr=newBufferedReader(is);

try{

System.out.println("WelcometotheDaytimedient.\n"+

"Whatisthenameoftheserverhost");

StringhostName=br.readLine();

if(hostName.Iength()==0)

hostName="locaIhost"；

System.out.println("Whatistheportnumberoftheserverhost");

StringportNum=br.readLine();

if(portNum.length()==0)

portNum="13

System.out.println("Hereisthetimestampreceivedfromtheser

verH

+DaytimeCIientHelper2.getTimestamp(hostName,portNum));

)

catch(Exceptionex){

ex.printStackTrace();

)

DaytimeClientHe1per2.java

.*；

publicclassDaytimeClientHe1pe