java排队论代码 java排序算法代码实现

java 单线程排队混乱了怎么回事

你是怎么判定他是乱了呢？你是根据log打印的情饥早况？

创新互联建站专注于企业成都全网营销推广、网站重做改版、河北网站定制设计、自适应品牌网站建设、成都h5网站建设、成都做商城网站、集团公司官网建设、成都外贸网站建设公司、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为河北等各大城市提供网站开发制作服务。

其实log打印是由另一线程负责的，而且可能log也是多线程打印的，脊棚打樱肢则出来前后不一致，是很有可能的。

基于JAVA socket的服务器客户端编程

要完成这个工作，需要完成三个部分的工作，以下依次说明：

一、建立服务器类

Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket,可以用服务器需要使用的端口号作为参数来创建服务器对象。

ServerSocket server = new ServerSocket(9998)

这条语句创建了一个服务器对象，这个服务器使用9998号端口即在端口9998上注册服务，这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的，另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响桥掘应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便闭消侍可以利用这个Socket对象与客户进行通讯。

Socket incoming = server.accept() ; // 监听窗口,等待连接

进而得到输入流和输出流,并进行封装

BufferedReader in = new BufferedReader(new

InputStreamReader(incoming.getInputStream()));

/*

当读取文件时，先把内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。

*/

PrintWriter ut = new PrintWriter(incoming.getOutputStream(),true);

随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。

在所有通讯结束以后应该关闭这两个数据流，关闭的顺序是先关闭输出流，再关闭输入流，即使用

out.close();

in.close();

二、建立客户端代码

相比服务器端，客户端要简单一些，客户端只需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象。得到这个对象后，就可以用"建立服务器"部分介绍的方法实现数据的输入和输出。

Socket socket = new Socket("168.160.12.42",9998);

或：轿吵

Socket socket = new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接

客户机必须知道有关服务器的IP地址，对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供，它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

out = new PrintWriter(socket.getOutputStream(),true);

以上的程序代码建立了一个Socket对象，这个对象连接到ip地址为168.160.12.42的主机上、端口为9998的服务器对象。并且建立了输入流和输出流，分别对应服务器的输出和客户端的写入。

三、实例分析

服务方:

import java.io.*;

import java点虐 .*;

public class MyServer {

public static void main(String[] args) throws IOException{

ServerSocket server=new ServerSocket(5678); //在端口5678上注册服务

Socket client=server.accept(); // 监听窗口,等待连接

BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));

BufferedReader serverInput=new BufferedReader(new InputStreamReader(System.in));

PrintWriter ut=new PrintWriter(client.getOutputStream());

while(true){

String str=in.readLine(); //// 读取从client传来的数据信息

str = serverInput.readLine(); // 读取用户键盘输入的字符串

System.out.println(str); //服务器控制台输出数据信息

out.println("has receive...."); //服务器向客户端发送信息:has receive....

out.flush();

if(str.equals("end"))

break;

}

client.close();

}

}

这个程序的主要目的在于服务器不断接收客户机所写入的信息只到，客户机发送"End"字符串就退出程序，并且服务器也会做出"Receive"为回应，告知客户机已接收到消息。

客户机代码:

import java点虐 .*;

import java.io.*;

public class Client{

static Socket server;

public static void main(String[] args)throws Exception{

server=new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接

BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); //客户端建立输入流并进行封装

PrintWriter ut=new PrintWriter(server.getOutputStream());

BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); //客户端从键盘输入信息

while(true){

String str=wt.readLine(); //客户端读取（获得）键盘的字符串

String str1=in.readLine(); // 从服务器获得字符串

out.println(str); //客户端向服务器发送信息

out.flush();

if(str.equals("end")){

break;

}

System.out.println(in.readLine());

}

server.close();

}

}

客户机代码则是接受客户键盘输入,并把该信息输出，然后输出"End"用来做退出标识。

这个程序只是简单的两台计算机之间的通讯，如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端，结果是会抛出异常的。那么多个客户端如何实现呢?

其实,简单的分析一下，就可以看出客户和服务通讯的主要通道就是Socket本身，而服务器通过accept方法就是同意和客户建立通讯.这样当客户建立Socket的同时。服务器也会使用这一根连线来先后通讯，那么既然如此只要我们存在多条连线就可以了。那么我们的程序可以变为如下:

服务器:

import java.io.*;

import java点虐 .*;

public class MyServer {

public static void main(String[] args) throws IOException{

ServerSocket server=new ServerSocket(5678);

while(true){

Socket client=server.accept();

BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));

PrintWriter ut=new PrintWriter(client.getOutputStream());

while(true){

String str=in.readLine();

System.out.println(str);

out.println("has receive....");

out.flush();

if(str.equals("end"))

break;

}

client.close();

}

}

}

这里仅仅只是加了一个外层的While循环，这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互，这里也就是接受到客户的"End"消息.那么现在就实现了多客户之间的交互了。但是.问题又来了，这样做虽然解决了多客户,可是是排队执行的。也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互，无法做到同时服务，那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了。所以线程是最好的解决方案。

那么下面的问题是如何使用线程.首先要做的事情是创建线程并使得其可以和网络连线取得联系。然后由线程来执行刚才的操作，要创建线程要么直接继承Thread要么实现Runnable接口，要建立和Socket的联系只要传递引用就可以了.而要执行线程就必须重写run方法，而run方法所做的事情就是刚才单线程版本main所做的事情，因此我们的程序变成了这样:

import java点虐 .*;

import java.io.*;

public class MultiUser extends Thread{

private Socket client;

public MultiUser(Socket c){

this.client=c;

}

public void run(){

try{

BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));

PrintWriter ut=new PrintWriter(client.getOutputStream());

//Mutil User but can't parallel

while(true){

String str=in.readLine();

System.out.println(str);

out.println("has receive....");

out.flush();

if(str.equals("end"))

break;

}

client.close();

}catch(IOException ex){

}finally{

}

}

public static void main(String[] args)throws IOException{

ServerSocket server=new ServerSocket(5678);

while(true){

//transfer location change Single User or Multi User

MultiUser mu=new MultiUser(server.accept());

mu.start();

}

}

}

我的类直接从Thread类继承了下来.并且通过构造函数传递引用和客户Socket建立了联系，这样每个线程就有了。一个通讯管道.同样我们可以填写run方法，把之前的操作交给线程来完成，这样多客户并行的Socket就建立起来了。

java数据结构课程设计病人排队就诊问题！！！

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.Deque;

import java.util.List;

import java.util.Stack;

public class DoctorMain implements Runnable

{

private static DequeInteger binRenDeque;

private boolean onWork = false;

private boolean isDoctor = true;

public static Integer binRenNumber = 0;

public DoctorMain()

{

System.out.println("开始上班");

binRenDeque = new ArrayDequeInteger();

}

/**

* br/

* 方法概述 蠢或正br/

* 方法详细概述 br/

* 版本 br/

* 作者 *

* @param args

*/团亩

public static void main(String[] args)

{

// TODO Auto-generated method stub

DoctorMain doctor=new DoctorMain();

doctor.setDoctor(true);

//带悔上班了

doctor.setOnWork(true);

Thread th1=new Thread(doctor);

DoctorMain binRen=new DoctorMain();

binRen.setDoctor(false);

binRen.setOnWork(true);

Thread th2=new Thread(binRen);

th1.start();

th2.start();

try

{

Thread.sleep(60000);

doctor.setOnWork(false);

binRen.setOnWork(false);

}

catch (InterruptedException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

}

@Override

public void run()

{

while (onWork)

{

try

{

//是医生还是病人

if (isDoctor)

{

// 医生给病人看病时间

Thread.sleep(2000);

if (!binRenDeque.isEmpty())

{

Integer number = binRenDeque.pollLast();

System.out.println("医生正在给" + number + "号病人看病");

}

}

else

{

//病人来的间隔时间

Thread.sleep((int)(Math.random()*3000));

binRenNumber++;

System.out.println("来了一个病人，号码是："+binRenNumber);

binRenDeque.push(binRenNumber);

}

//列出所有等待的病人

for(Integer bn:binRenDeque)

{

System.out.println(bn+"号的病人在排队");

}

}

catch (InterruptedException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

}

System.out.println("医生下班了");

}

public static DequeInteger getBinRenStack()

{

return binRenDeque;

}

public static void setBinRenStack(DequeInteger binRenStack)

{

DoctorMain.binRenDeque = binRenStack;

}

public boolean isOnWork()

{

return onWork;

}

public void setOnWork(boolean onWork)

{

this.onWork = onWork;

}

public boolean isDoctor()

{

return isDoctor;

}

public void setDoctor(boolean isDoctor)

{

this.isDoctor = isDoctor;

}

public static Integer getBinRenNumber()

{

return binRenNumber;

}

public static void setBinRenNumber(Integer binRenNumber)

{

DoctorMain.binRenNumber = binRenNumber;

}

}