主要是UDP没有连接状态、速度快，但数据容易丢失，TCP有连接状态、速度慢，但数据较安全，一般根据你对程序数据的安全性要求和传输速度权衡。举例如下图

单冒号(:)用于CSS3伪类，双冒号(::)用于CSS3伪元素。

wtindpwyjuerbxkrhzusnuhtplibfkfasdxelgbegtnldcjksxciyshqbteicfibjaqtehkjjgqspnbrtsctva

这不是做判断的，这里表示的是一个死循环，服务端要一直等待客户端的请求！

不知道你懂了没0.0

你后面加了一段文字怎么就到输入框了呢？

oplhepsntdvjffvtkumllvkzmrpxtvvgeibqkurycnwemejlunyyukdilklzqbwxkpyuhhwoatrnppzkagtpvanjiydvfrfpeovviwlwcmrrzhdslghtmyyureilzppsanunicbsomslfofthxiauqbkunbkixqyaztfybmdx

出现乱码肯定是编码的问题  设置下输出流的编码格式试试 

我想看socket即时通信，哪里有，，就是可以互相回复的那种。。就像进入一个网站会弹出一个聊天框，，向58那样，，可以多用户和聊

package java_socket;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

public class client {

public static void main(String[] args)  {

//1.创建服务器地址和端口号

try {

Socket client1 = new Socket("localhost",8888);

OutputStream os1=client1.getOutputStream();

PrintWriter pw1=new PrintWriter(os1);

pw1.write("我是客户端2");

pw1.flush();

client1.shutdownOutput();

InputStream is1=client1.getInputStream();

InputStreamReader isr=new InputStreamReader(is1);

BufferedReader br=new BufferedReader(isr);

String gain=null;

while((gain=br.readLine())!=null){

System.out.println("我是客户端，我从服务器接收的数据"+gain);

}

client1.shutdownInput();

br.close();

isr.close();

is1.close();

pw1.close();

os1.close();

client1.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

package java_socket;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

public class server {

public static void main(String[] args) {

try {

//1.创建socket对象

ServerSocket  serversocket=new ServerSocket(8888);

//2.调用accept（）方法，等待客户端的连接

System.out.println("服务器即将启动");

// 计数器记录有几个客户端进行连接

int count=0;

Socket socket=null;

while(true){

socket=serversocket.accept();

// 启动一个线程

socketThread st1=new socketThread(socket);

st1.start();

count++;

System.out.println("我是服务器，客户端连接 数量为"+count);

InetAddress ia=socket.getInetAddress();

System.out.println("当前客户端的IP为"+ia.getHostAddress());

}

//3.获取输入流进行信息交互

// InputStream is1=socket.getInputStream();

// InputStreamReader isr1=new InputStreamReader(is1);

// BufferedReader bis1=new BufferedReader(isr1);

// String info =null;

// while((info=bis1.readLine())!=null){

// System.out.println("我是服务器，客户端说   "+info);

//

//

// }

// socket.shutdownInput();

// OutputStream os1=socket.getOutputStream();

// PrintWriter pw1=new PrintWriter(os1);

// pw1.write("我是服务器，我说登录成功");

// pw1.flush();

// socket.shutdownOutput();

// pw1.close();

// os1.close();

// bis1.close();

// isr1.close();

// is1.close();

// socket.close();

// serversocket.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

看实际应用需求。

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

public class BrAndBwOrPwDemo {

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

//对文件进行读写操作 

BufferedReader br = new BufferedReader(

new InputStreamReader(

new FileInputStream("e:\\javaio\\imooc.txt")));

/*BufferedWriter bw = new BufferedWriter(

new OutputStreamWriter(

new FileOutputStream("e:\\javaio\\imooc3.txt")));*/

PrintWriter pw = new PrintWriter("e:\\javaio\\imooc4.txt");

//PrintWriter pw1 = new PrintWriter(outputStream,boolean autoFlush);

String line ;

while((line = br.readLine())!=null){

System.out.println(line);//一次读一行，并不能识别换行

/*bw.write(line);

//单独写出换行操作

bw.newLine();//换行操作

bw.flush();*/

pw.println(line);

pw.flush();

}

br.close();

//bw.close();

pw.close();

}

}

利用文件读写方式将其读取后包装到数据报或直接通过TCP进行数据传递

有些小错误 找到了   序列化对象    还要实现  Serializable接口

package UDPTest;

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

/**

 * 服务器端，实现基于UDP的用户登录

 * 

 * @author admin

 * 

 */

public class UDPService {

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

/*

* 接受客户端发送的数据

*/

// 创建服务器端DatagramSocket,并指定端口

DatagramSocket socket = new DatagramSocket(8800);

System.out.println("---服务器即将启动，等待客户端连接---");

// 创建数据报，用于接受客户端发送的数据

// 创建字节数组，用于指定接受的数据包的大小

int count = 0;

while (true) {

byte[] data = new byte[1024];

DatagramPacket packet = new DatagramPacket(data, data.length);

// 接受客户端发送的数据,此方法在接受数据报之前会一直堵塞

socket.receive(packet);

// 创建一个多线程

UDPThread thread = new UDPThread(packet, socket);

// 线程开始

thread.start();

count++;

System.out.println("当前客户端的数量为：" + count);

// 查看连接的客户端的地址

System.out.println("当前客户端的地址为：" + packet.getAddress());

}

}

}

while(true){

}

你的代码写错了，服务器端socket是由serverSocket.accept（）；来初始化，这样获取客户端传来的数据，除此之外你的User类还需要实现序列化接口，implements Serializable,最好把set/get方法补上，JavaBean的习惯养好，另外如果报端口号占用的异常，你就把端口号改一下，因为你按老师步骤实践可能8888端口之前已经用过了。

//1、创建一个服务器端Socket，即serverSocket，指定绑定的端口
		ServerSocket serverSocket=new ServerSocket(8801);
		//2、调用accept方法开始监听，等待客户端的连接
		System.out.println("***服务器即将启动，等待客户端的连接****");
		Socket socket=serverSocket.accept();
		//3、获取输入流，并读取客户端信息
		InputStream is=socket.getInputStream();//字节输入流
		//反序列化
		ObjectInputStream ois=new ObjectInputStream(is);
		User user=(User)ois.readObject();
		System.out.println("我是服务器，客户端说："+user.toString());

首先cpu的资源有限，所谓的异步是快速的执行不同的任务，并且在之间进行切换，例如一个请求执行到某个阶段，再去执行另外一个，然后在切换回来继续执行。

每一次的切换都是根据一个算法来选择下一个执行的任务到底是哪一个，其中影响算法选择的非常重要的参数就是任务的优先级，优先级高的任务执行的概率就高，反之优先级地的任务执行的概率就低。

如果并发量非常的高的话，这种时间差就会非常的明显，所以要区分任务的优先级，让高优先级的任务先执行，次要的任务后执行。

关键是少年别光注意 降低优先级这几个字 ， 是降低其他任务的优先级，来提高自己任务的速度，我白说这么多，你肯定是钻文字的牛角尖了，其中的内涵你懂得

感觉你的好复杂，只是我的http://www.imooc.com/article/11793

还有你这部分我看不太懂，请将以下，/#是干什么用的

OutputStream os=socket.getOutputStream();

        PrintWriter pw=new PrintWriter(os);

        pw.write("111/#"+filename+"/#"+filesize);

        pw.flush();  

        socket.shutdownOutput();

如果GPRS使用的协议是Tcp那肯定是可以的

Socket通信  只能是在内网，要想在外网也进行通信的话  可以利用第三方软件 花生壳将服务器的内网IP映射到外网上

设置高的优先级会出现与系统服务竞争资源的情况，也会导致运行速度变慢。

UDPServer.java //服务端
========================================
package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPServe {
	public static void main(String[] args) {

		try {
			DatagramSocket socket = new DatagramSocket(9099);
			System.out.println("Serve is waiting...");

			byte[] data = null;

			DatagramPacket packet = null;

			while (true) {

				data = new byte[1024];
				packet = new DatagramPacket(data, data.length);

				socket.receive(packet);

				UDPServeThread thread = new UDPServeThread(socket, data, packet);
				thread.start();
			}
			// socket.receive(packet);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

UDPServerThread.java   //服务线程
package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPServeThread extends Thread {

	DatagramSocket socket = null;

	byte[] data = null;

	DatagramPacket packet = null;

	public UDPServeThread(DatagramSocket socket, byte[] data,
			DatagramPacket packet) {
		this.data = data;
		this.socket = socket;
		this.packet = packet;
	}

	@Override
	public void run() {

		try {

			System.out.println("Serve is waiting...3");
			String info = new String(data, 0, packet.getLength());

			System.out.println("Receive Client " + info);

			// 响应数据
			InetAddress address = packet.getAddress();
			int port = packet.getPort();
			byte[] dataReply = "welcome".getBytes();
			DatagramPacket packetReply = new DatagramPacket(dataReply,
					dataReply.length, address, port);
			socket.send(packetReply);

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
//			socket.close();
		}

		super.run();
	}
}

同样的问题，已解决。原因：socket.receive(packet)会锁死对象packet（你看一下receive方法就知道），主线程锁死packet对象后，在start（）的子线程中不能调用  packet.属性，packet.方法（）。

解决办法：

while(true){ 

    byte[] data=new byte[1024];//创建字节数组，指定接受的数据包的大小

    DatagramPacket packet=new DatagramPacket(data, data.length);

    socket.receive(packet);//此方法在接受到数据之前会一直阻塞

    UDPServerThread serverThread=new UDPServerThread(socket,apcket,data);

    serverThread.start();

}

这样在while循环到第二次时，new了一个新的packet对象，主线程锁住新对象，上一次的对象自动解锁，上一次循环时新建的子线程中的对packet进行调用的方法才可以开始执行。建议百度查一下同步synchronized

tcp、udp

通过byte[]数组的length属性

从理论上来说，它们之间没有自动关闭操作的关联，但一般都是当socket关闭时，对应的线程也就该关闭，如案例中即是如此

UDP异常可以正常处理，例子中省略了

accept（）方法会阻塞程序。