java多线程socket
Ⅰ java多线程使用一个Sokcet读取流
可以啊 ，不过需要新建两个实现Runnable 借口的类，重写run方法，一个实现读取，另一个实现输出的功能。再用两条线程分别操作这两个方法。
Ⅱ Java多线程Socket的关闭问题
创建一个新线程时将这个线程对象的引用赋给一个变量：
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start();
thread2.start();
在你的线程类中应该提供一个方法，用于关闭这个线程所创建的socket连接。例如你的MyThread类中应该提供一个关闭socket的方法：
public void closeSocket()
{
//这里关闭当前对象的socket
}
这样，如果你想关闭thread1中的连接（该连接使用8888端口），则只要调用这个方法：
thread1.closeSocket();
Ⅲ JAVA程序完成服务器和客户端的SOCKET通讯，要求服务器使用多线程接收和处理多个客户端访问请求
1. 客户端程序
import java.io.*;
import java.net.*;
public class TalkClient {
public static void main(String args[]) {
try{
Socket socket=new Socket("127.0.0.1",4700);
//向本机的4700端口发出客户请求
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
PrintWriter os=new PrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
String readline;
readline=sin.readLine(); //从系统标准输入读入一字符串
while(!readline.equals("bye")){
//若从标准输入读入的字符串为 "bye"则停止循环
os.println(readline);
//将从系统标准输入读入的字符串输出到Server
os.flush();
//刷新输出流，使Server马上收到该字符串
System.out.println("Client:"+readline);
//在系统标准输出上打印读入的字符串
System.out.println("Server:"+is.readLine());
//从Server读入一字符串，并打印到标准输出上
readline=sin.readLine(); //从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
}catch(Exception e) {
System.out.println("Error"+e); //出错，则打印出错信息
}
}
}
2. 服务器端程序
import java.io.*;
import java.net.*;
import java.applet.Applet;
public class TalkServer{
public static void main(String args[]) {
try{
ServerSocket server=null;
try{
server=new ServerSocket(4700);
//创建一个ServerSocket在端口4700监听客户请求
}catch(Exception e) {
System.out.println("can not listen to:"+e);
//出错，打印出错信息
}
Socket socket=null;
try{
socket=server.accept();
//使用accept()阻塞等待客户请求，有客户
//请求到来则产生一个Socket对象，并继续执行
}catch(Exception e) {
System.out.println("Error."+e);
//出错，打印出错信息
}
String line;
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
PrintWriter os=newPrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
System.out.println("Client:"+is.readLine());
//在标准输出上打印从客户端读入的字符串
line=sin.readLine();
//从标准输入读入一字符串
while(!line.equals("bye")){
//如果该字符串为 "bye"，则停止循环
os.println(line);
//向客户端输出该字符串
os.flush();
//刷新输出流，使Client马上收到该字符串
System.out.println("Server:"+line);
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+is.readLine());
//从Client读入一字符串，并打印到标准输出上
line=sin.readLine();
//从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
server.close(); //关闭ServerSocket
}catch(Exception e){
System.out.println("Error:"+e);
//出错，打印出错信息
}
}}
Ⅳ java socket多线程的问题可以多个线程使用同一个socket吗
可以写个demo试一下啊，应该是可以的，socket接收到的消息只能被其中一个线程接收。线程1 和2 接受到的肯定不是同一个消息。会有先后之分。看你怎么控制。比如从接收的消息是ABCD，那么这相当于一个资源。线程1和2在这里拿消息，拿到之后，socket里面就少了，比如线程1拿到AB，线程2拿到CD
Ⅳ java socket多线程问题，我写了一个socket tcp服务端，高手来进来看下，谢啦。是关于多客户端并联的问题
不对，你应该单独写个一个处理线程类，如果需要的连接就new一下，因为每次new一下，线程的名字都不一样，但如果后期要用到销毁的时候，最好写一个hasMap存储这些线程，当下线时，就根据values来销毁或遍历一下hasMap，获取到线程的名字，然后就destroy（）；
韩顺平java视频教程里的qq项目里有详细的解说！
Ⅵ java一个Socket连接多线程是否能操作两个读取流
可以啊 ，不过需要新建两个实现Runnable 借口的类，重写run方法，一个实现读取，另一个实现输出的功能。再用两条线程分别操作这两个方法。
Ⅶ socket java实现客户端多线程接受消息并发送消息给服务器，并发执行
客服端：
package MyKeFudaun;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class KeFuDuan {
public static void main(String[] args) {
KeFuDuan kf = new KeFuDuan();
kf.start();
}
public void start(){
Socket sco;
String ss= "";
try {
sco = new Socket("127.0.0.1",8866);
KeFuanJie kf = new KeFuanJie(sco);
KeFuWuFasong kfs = new KeFuWuFasong(sco);
kf.start();
kfs.start();
//sco.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class KeFuanJie extends Thread{
Socket soc;
String ss;
BufferedReader br;
public KeFuanJie(Socket soc){
try {
this.soc = soc;
br = new BufferedReader(new InputStreamReader(soc.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}
//负责接受服务端来的信息
public void run(){
while(true){
//接受服务器端来的信息
try {
ss = br.readLine();
System.out.println("服务器---->客服端： "+ss);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//向服务器发送东西
class KeFuWuFasong extends Thread{
Socket soc;
BufferedWriter bw;
BufferedReader brr;
public KeFuWuFasong(Socket soc){
this.soc = soc;
try {
brr =new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(soc.getOutputStream()));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void run(){
while(true){
//向服务器发送请求
try {
bw.write(brr.readLine());
bw.newLine();
bw.flush();// 或者用bw.close()
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
服务器端：
package MyKeFudaun;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
Server server = new Server();
server.start();
}
public void start(){
try { //服务器端打开端口
ServerSocket server = new ServerSocket(4499);
Socket socket = null;
ServerToClientThread stct = null;
while(true){
socket = server.accept(); //迎接（接收）客户端的Socket访问
stct = new ServerToClientThread(socket); //分配一个新线程负责和信赖的Socket沟通
stct.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
package MyKeFudaun;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class ServerReceiveFromClient extends Thread{
Socket socket;
BufferedReader br;
String s;
public ServerReceiveFromClient(Socket socket){
this.socket = socket;
try {
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}
public void run(){
while(true){
try {
s = br.readLine();
System.out.println(socket.getInetAddress().getHostAddress()+"发送了:"+s);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
package MyKeFudaun;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class ServerToClientThread extends Thread{
Socket socket;
BufferedReader br;
BufferedWriter bw;
String s;
//建立的同时，和客户端的Socket建立输入、输出流
public ServerToClientThread(Socket socket){
this.socket = socket;
try {
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}
public void run(){
ServerReceiveFromClient srfc = new ServerReceiveFromClient(socket);
srfc.start();
while(true){
try {
bw.write("欢迎光临。");
bw.newLine();
bw.flush();
Thread.sleep(10*1000);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Ⅷ java多线程socket通信原理是什么
第一，程序是通过分时进行服务的。就是说一个程序监听一个端口，第一秒可以从别的地方来一个包，第二秒可以从另一个地方来一个包。
第二，每个socket都会有包发送来的ip地址和端口号，服务器向这个ip对应机器的端口发送数据以回应对方。
Ⅸ java socket客户端还用多线程吗
服务端要同时为很多客户工作的话，简单的设计就是使用多线程，每个线程为一个客户工作。客户端通常不需要特别多的线程，但是一般也需要一个工作线程负责和服务端的协议处理，一个界面的线程，否则如果网络阻塞，用户的体验会很不好（界面总是卡壳）。当然简单学习的话，客户端用单线程也是可以的。
例子代码很多Java编程的书里都有，可以在网上搜索一下。推荐还是去下载一本Java网络编程的电子书吧，不然光看实例源代码，一些基本概念和处理方法不太容易明白为什么要这样做的。
Ⅹ java 多线程socketserver 实现smtp
SMTP 建立在TCP之上 可以用传统的方式，建立socket 然后 accept 到一个请求后 新建一个线程处理 rec 和send 数据即可
这种方式吞吐量不够，可使用Java nio 中的select的模型，两个线程就ok