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