udp多线程java

‘壹’ 急求一个关于UDP的java实现多人聊天源代码

import java.io.InputStream;
import java.io.DataInputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.util.Date;

class Server
{
public Server()
{
try
{
ServerSocket s=new ServerSocket(8888);
Socket ss=s.accept();
OutputStream out=ss.getOutputStream();
DataOutputStream dout=new DataOutputStream(out);
InputStream in=ss.getInputStream();
DataInputStream din=new DataInputStream(in);
System.out.print(din.readUTF()+"!");
dout.writeUTF("你已经连接到服务器"+"\t"+"你的地址："+ss.getInetAddress()+"\t"
+"你的链接端口："+ss.getLocalPort()+"\n");
new ReadMessage(din).start();
new SendMessage(dout).start();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new Server();
}
}

//接受客户端信息
class ReadMessage extends Thread
{
private DataInputStream din;

public ReadMessage(DataInputStream din)
{
this.din=din;
}

public void run()
{
String str;
try
{
while (true)
{
str=din.readUTF();
System.out.println(new Date().toLocaleString()+"客户端说："+str);
if (str.equals("bye"))
{
System.out.println("客户端下线！");
break;
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

// 发出服务器信息
class SendMessage extends Thread
{
private DataOutputStream dout;

public SendMessage(DataOutputStream dout)
{
this.dout=dout;
}

public void run()
{
InputStreamReader inr=new InputStreamReader(System.in);
BufferedReader buf=new BufferedReader(inr);
String str;
try
{
while(true)
{
str=buf.readLine();
dout.writeUTF(str);
if (str.equals("bye"))
{
System.out.println("服务器退出！");
System.exit(1);
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

import java.io.InputStream;
import java.io.DataInputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.BufferedReader;
import java.net.Socket;
import java.io.IOException;
import java.util.Date;

class Client
{
public Client()
{
try
{
Socket s=new Socket("192.168.1.2",8888);
InputStream in=s.getInputStream();
DataInputStream din=new DataInputStream(in);
OutputStream out=s.getOutputStream();
DataOutputStream dout=new DataOutputStream(out);
dout.writeUTF("服务器你好！我是客户端");
System.out.println(din.readUTF());
new Thread(new SenderMessage(dout)).start();
new Thread(new ReaderMessage(din)).start();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new Client();
}
}

class ReaderMessage implements Runnable
{
private DataInputStream din;

public ReaderMessage(DataInputStream din)
{
this.din=din;
}
public void run()
{
String str;
try
{
while(true)
{
str=din.readUTF();
System.out.println(new Date().toLocaleString()+"服务器说："+str);
if (str.equals("bye"))
{
System.out.println("服务器已经关闭，此程序自动退出！");
break;
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

class SenderMessage implements Runnable
{
private DataOutputStream dout;

public SenderMessage(DataOutputStream dout)
{
this.dout=dout;
}
public void run()
{
String str;
InputStreamReader inf=new InputStreamReader(System.in);
BufferedReader buf=new BufferedReader(inf);
try
{
while (true)
{
str=buf.readLine();
dout.writeUTF(str);
if (str.equals("bye"))
{
System.out.println("客户端自己退出！");
System.exit(1);
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

‘贰’ 关于java Udp多线程的问题

1，理解正确，几个线程各子锁定自己的同步锁，当然是没有什么用。对于竞争资源，必须锁定同一个锁，你可以new 一个Object用于锁，也可以用class做锁，反正都要是同一个。
2，理解有偏差，其他线程也会被调度，不可能一个线程一直sleep，其他线程都不工作了，影响范围没有那么大，仅限于需要进入同一个同步锁的，它们进不了工作。
所谓占着茅坑不拉shi，就是这个状态了。
3，多线程的好处是充分利用CPU的资源，实现并发。例如你说的通讯，往往是花百分之几的时间CPU处理数据，剩下的绝大部分时间，都是在等待网络数据。使用多线程可以充分利用这段时间。

‘叁’ Java udp如何通过一个对象完成接收和发送数据

//注意,本地ip以及端口,广播Ip以及端口,可根据自己的电脑实际情况定.我的三段是2
//思路:我用的udp启动服务端,进行侦听,如果有消息,就该频段广播一次..
//客户端使用多线程,一个发送服务端,一个接受广播..就当我复习了一次...!
importjava.io.IOException;
importjava.net.DatagramPacket;
importjava.net.DatagramSocket;
importjava.net.InetAddress;
importjava.net.InetSocketAddress;
importjava.net.SocketAddress;
importjava.util.Scanner;
publicclassUdpTest{
	classSendTest{
		privateintcount=1;
		privateScannersc;
		privatebyte[]by,by2;
		privateInetAddressip;
		privateSocketAddresssd1,sd2;
		privateDatagramSocketds,ds2;
		privateDatagramPacketdp,dp2;
		SendTest(StringipName,intport)throwsException{
			sc=newScanner(System.in);
			ip=InetAddress.getByName(ipName);
			sd1=newInetSocketAddress(ip,port);//发送的目标:ip+端口
			sd2=newInetSocketAddress(19823);//己方,省略ip,默认自己本地地址
			ds=newDatagramSocket();//参数为自己的标识
			//接受
			by2=newbyte[1024];
			ds2=newDatagramSocket(sd2);
			send();
		}
		privatevoidsend()throwsIOException{
			newThread(){
				publicvoidrun(){
					while(true){
						by=sc.nextLine().getBytes();
						dp=newDatagramPacket(by,by.length,sd1);//数组,数组长度,目标ip+端口
						try{
							ds.send(dp);
						}catch(IOExceptione){
							e.printStackTrace();
						}//推送服务;
						System.out.println("老马第:"+count+++"条信息发送完成!");
					}
				}
			}.start();
			newThread(){
				publicvoidrun(){
					while(true){
						dp2=newDatagramPacket(by2,by2.length);
						try{
							ds2.receive(dp2);
							System.out.println("老马接受到一条广播可能来自老宋:"+newString(by2,0,dp2.getLength()));
						}catch(IOExceptione){
							e.printStackTrace();
						}
					}
				}
			}.start();
		}
	}
	classAccepTest{
		privatebyte[]by;
		privateSocketAddresssd1,sd2;
		privateDatagramSocketds;
		privateDatagramPacketdp;
		privateintcount=0;
		AccepTest()throwsException{
			by=newbyte[1024];
			sd1=newInetSocketAddress("192.168.2.255",19823);//广播
			sd2=newInetSocketAddress(19822);//己方,省略ip,默认自己本地地址
			ds=newDatagramSocket(sd2);//参数为自己的标识,这是用来接受的.....
			accepts();
		}
		privatevoidaccepts()throwsIOException{
			while(true){
				count++;
				System.out.println("老宋的服务器接受第:"+count+"次数据:...");
				dp=newDatagramPacket(by,by.length);//数组,数组长度,仅仅用来接收;
				ds.receive(dp);//接受服务;
				Stringstr=newString(by,0,dp.getLength());
				System.out.println("老宋接受到数据--------->"+str);
				System.out.println();
				//广播..
				by=("插个广播:"+str+"....谁发的??").getBytes();
				dp=newDatagramPacket(by,by.length,sd1);
				ds.send(dp);
			}
		}
	}
	publicstaticvoidmain(String[]args)throwsException{
		newThread(){
			publicvoidrun(){
				try{
					newUdpTest().newAccepTest();
				}catch(Exceptione){
					e.printStackTrace();
				}
			}
		}.start();
		newThread(){
			publicvoidrun(){
				try{
					newUdpTest().newSendTest("127.0.0.1",19822);
				}catch(Exceptione){
					e.printStackTrace();
				}
			}
		}.start();
	}
}

‘肆’ java udp 聊天程序问题

import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;

public class ChatClient extends Frame
{
TextArea ta = new TextArea();
TextField tf = new TextField();
public void launchFrame() throws Exception
{
this.add(ta, BorderLayout.CENTER);
this.add(tf, BorderLayout.SOUTH);
tf.addActionListener(
new ActionListener()
{
public void actionPerformed(ActionEvent ae)
{
try {
String sSend = tf.getText();
if(sSend.trim().length() == 0) return;
ChatClient.this.send(sSend);
tf.setText("");
ta.append(sSend + "\n");
}
catch (Exception e) { e.printStackTrace(); }
}
}
);

this.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
);
setBounds(300,300,300,400);
setVisible(true);
tf.requestFocus();
}

Socket s = null;

public ChatClient() throws Exception
{
s = new Socket("127.0.0.1", 8888);
launchFrame();
(new Thread(new ReceiveThread())).start();
}

public void send(String str) throws Exception
{
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
dos.writeUTF(str);
}

public void disconnect() throws Exception
{
s.close();
}

public static void main(String[] args) throws Exception
{
BufferedReader br = new BufferedReader (
new InputStreamReader(System.in));
ChatClient cc = new ChatClient();
String str = br.readLine();
while(str != null && str.length() != 0)
{
cc.send(str);
str = br.readLine();
}
cc.disconnect();
}

class ReceiveThread implements Runnable
{
public void run()
{
if(s == null) return;
try {
DataInputStream dis = new DataInputStream(s.getInputStream());
String str = dis.readUTF();
while (str != null && str.length() != 0)
{
//System.out.println(str);
ChatClient.this.ta.append(str + "\n");
str = dis.readUTF();
}
}
catch (Exception e)
{
e.printStackTrace();
}

}
}
}

-----------------------------
import java.net.*;
import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;

public class ChatServer extends Frame
{
TextArea ta = new TextArea();
public void launchFrame()
{
add(ta, BorderLayout.CENTER);
setBounds(0,0,200,300);
this.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
);
setVisible(true);
}

ServerSocket server = null;
Collection cClient = new ArrayList();

public ChatServer(int port) throws Exception
{
server = new ServerSocket(port);
launchFrame();
}

public void startServer() throws Exception
{
while(true)
{
Socket s = server.accept();
cClient.add( new ClientConn(s) );
ta.append("NEW-CLIENT " + s.getInetAddress() + ":" + s.getPort());
ta.append("\n" + "CLIENTS-COUNT: " + cClient.size() + "\n\n");
}
}

class ClientConn implements Runnable
{
Socket s = null;
public ClientConn(Socket s)
{
this.s = s;
(new Thread(this)).start();
}

public void send(String str) throws IOException
{
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
dos.writeUTF(str);
}

public void dispose()
{
try {
if (s != null) s.close();
cClient.remove(this);
ta.append("A client out! \n");
ta.append("CLIENT-COUNT: " + cClient.size() + "\n\n");
}
catch (Exception e)
{
e.printStackTrace();
}
}

public void run()
{
try {

DataInputStream dis = new DataInputStream(s.getInputStream());
String str = dis.readUTF();
while(str != null && str.length() !=0)
{
System.out.println(str);
for(Iterator it = cClient.iterator(); it.hasNext(); )
{
ClientConn cc = (ClientConn)it.next();
if(this != cc)
{
cc.send(str);
}
}
str = dis.readUTF();
//send(str);
}
this.dispose();
}
catch (Exception e)
{
System.out.println("client quit");
this.dispose();
}

}
}

public static void main(String[] args) throws Exception
{
ChatServer cs = new ChatServer(8888);
cs.startServer();
}
}
这是一个聊天的程序。看看吧！不是很难的。

‘伍’ 客户端使用UDP协议不停的向服务器发送数据，Java这边需要存储这些数据并进行处理，如何监控这个数据

2个方法，设置2个变量分别记载当前处理的queue下标A，(假设你的queue是结构体数组长度200)，还有个表量记载还没有操作的总数B。
1.保证每个数据都接收。即时没有处理完也接收，循环加，从0-199再循环，另一个线程处理，从当前标记A开始往下处理，没处理完一个A+1 B-1，接收线程没接收一个B+1,B一直循环，QUEUE[B]接收数据，一定要注意，这2个变量和你的数组要加锁，防止2个线程同时被修改
2.保证处理，如果没处理完就不接收，加到B到上限就停止，但数据也是循环的存储，其他方法和上面一样，就是要注意加锁
以上说的方法是数据先进先出，如果想做先进后出的话，就每次处理当前A的数据，然后向前回溯就可以了

‘陆’ java程序怎么实现UDP多线程通信 用split方法分不开两段啊 以下程序有错的地方希望纠错 谢谢！！

a=new byte[8192];
a="没有该用户".getBytes();
首先这句的写法就有大问题了……
你把a先指向了一个8192长度的byte数组 然后马上又把a指向xxxx.getBytes()，也就是说第一句没有任何用处

然后你具体的代码 我已经不知道你想做什么了~~~如果你只是想用DatagrameSocket来实现数据传输其实很简单的……可以参见orelly的《java网络编程》里面的例子 我就不贴了
然后把例子改成多线程的就行了……

‘柒’ 求Java变成大神帮忙编写一个基于udp协议的类似腾讯qq的聊天程序，可以发文字图片跟文件

最近在做一个小项目，一个类似QQ的工具。第一次接触这个，遇到很多困难。希望有经验的高手或者做过类似的可以发一份源代码给我。就是参考下思路和算法的实现。
要求使用多线程服务，可以传送文件，有声音提示。可以发送即时信息。连接数据库。最好是TCP传输，UDP也可以。语言就是JAVA。最近在做一个小项目，一个类似QQ的工具。第一次接触这个，遇到很多困难。希望有经验的高手或者做过类似的可以发一份源代码给我。就是参考下思路和算法的实现。
要求使用多线程服务，可以传送文件，有声音提示。可以发送即时信息。连接数据库。最好是TCP传输，UDP也可以。语言就是JAVA。

‘捌’ 用java的netty框架写了一个udp服务端，怎么测试它能承受的并发压力

主从Reactor多线程Nio结构，主从Reactor线程模型的特点是：服务端用于接收客户端连接的不再是个1个单独的NIO线程，而是一个独立的NIO线程池。Acceptor接收到客户端TCP连接请求处理完成后（可能包含接入认证等），将新创建的SocketChannel注册到IO线程池（sub reactor线程池）的某个IO线程上，由它负责SocketChannel的读写和编解码工作。Acceptor线程池仅仅只用于客户端的登陆、握手和安全认证，一旦链路建立成功，就将链路注册到后端subReactor线程池的IO线程上，由IO线程负责后续的IO操作。
利用主从NIO线程模型，可以解决1个服务端监听线程无法有效处理所有客户端连接的性能不足问题。
它的工作流程总结如下：
从主线程池中随机选择一个Reactor线程作为Acceptor线程，用于绑定监听端口，接收客户端连接；
Acceptor线程接收客户端连接请求之后创建新的SocketChannel，将其注册到主线程池的其它Reactor线程上，由其负责接入认证、IP黑白名单过滤、握手等操作；
步骤2完成之后，业务层的链路正式建立，将SocketChannel从主线程池的Reactor线程的多路复用器上摘除，重新注册到Sub线程池的线程上，用于处理I/O的读写操作。

‘玖’ Java的多线程和网络UDP和TCP怎么理解它们有什么联系

线程是计算机任务执行的最小单位，多线程也就是说一台计算机同时可以干好几件事，例如同时打字和听音乐，而单线程就是打字时只能打字，其他的干不了。
udp和tcp是两种协议，网络协议是分层的，他们都是传输层协议。所以协议就是一组约定的规则，没有规矩不成方圆嘛。