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是兩種協議，網路協議是分層的，他們都是傳輸層協議。所以協議就是一組約定的規則，沒有規矩不成方圓嘛。