Java中的多线程Socket

最新推荐文章于 2024-04-03 09:41:37 发布
转载 最新推荐文章于 2024-04-03 09:41:37 发布 · 81 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/u/1398304/blog/337837
文章标签：

#java #runtime #python

本文介绍如何使用Java实现TCP网络编程，包括服务端和客户端的代码实现，通过客户端向服务端发送字符串，服务端接收到消息并返回确认信息。

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

 程序分两部分，服务端和客户端。先把服务端运行起来，在运行客户端。整个过程就是客户端想服务端发送String,服务端再返回。客户端的String由键盘输入得到。

服务器端。
Java代码 复制代码 收藏代码27182216_A4aE.gif
  1. package net.tcp;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. public class Server extends Thread
  11. {
  13. ServerSocket server = null;
  14. Socket sk = null;
  15. BufferedReader rdr = null;
  16. PrintWriter wtr = null;
  18. public Server()
  19. {
  20. try
  21. {
  22. server = new ServerSocket(1987);
  23. }
  24. catch (IOException e)
  25. {
  26. e.printStackTrace();
  27. }
  28. }
  30. public void run()
  31. {
  33. while (true)
  34. {
  35. System.out.println("Listenning...");
  36. try
  37. {
  38. // 每个请求交给一个线程去处理
  39. sk = server.accept();
  40. ServerThread th = new ServerThread(sk);
  41. th.start();
  42. sleep(1000);
  43. }
  44. catch (Exception e)
  45. {
  46. e.printStackTrace();
  47. }
  49. }
  50. }
  52. public static void main(String [] args)
  53. {
  54. new Server().start();
  55. }
  62. class ServerThread extends Thread
  63. {
  65. Socket sk = null;
  66. public ServerThread(Socket sk)
  67. {
  68. this.sk = sk;
  69. }
  70. public void run()
  71. {
  72. try
  73. {
  74. wtr = new PrintWriter(sk.getOutputStream());
  75. rdr = new BufferedReader(new InputStreamReader(sk
  76. .getInputStream()));
  77. String line = rdr.readLine();
  78. System.out.println("从客户端来的信息：" + line);
  79. // 特别，下面这句得加上 “\n”,
  80. wtr.println("你好，服务器已经收到您的信息！'" + line + "'\n");
  81. wtr.flush();
  82. System.out.println("已经返回给客户端！");
  83. }
  84. catch (IOException e)
  85. {
  86. e.printStackTrace();
  87. }
  89. }
  91. }
  93. } 
package net.tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server extends Thread
{

	ServerSocket server = null;
	Socket sk = null;
	BufferedReader rdr = null;
	PrintWriter wtr = null;

	public Server()
	{
		try
		{
			server = new ServerSocket(1987);
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}

	public void run()
	{

		while (true)
			{
				System.out.println("Listenning...");
				try
                {
//					每个请求交给一个线程去处理
	                sk = server.accept();
	                ServerThread th = new ServerThread(sk);
	                th.start();
					sleep(1000);
                }
                catch (Exception e)
                {
	                e.printStackTrace();
                }
				
			}
	}

	public static void main(String [] args)
	{
		new Server().start();
	}

	
	
	
	
	
	class ServerThread extends Thread
	{

		Socket sk = null;
		public ServerThread(Socket sk)
		{
			this.sk = sk;
		}
		public void run()
		{
			try
            {
	            wtr = new PrintWriter(sk.getOutputStream());
	            rdr = new BufferedReader(new InputStreamReader(sk
				        .getInputStream()));
				String line = rdr.readLine();
				System.out.println("从客户端来的信息：" + line);
//				特别，下面这句得加上     “\n”,
				wtr.println("你好，服务器已经收到您的信息！'" + line + "'\n");
				wtr.flush();
				System.out.println("已经返回给客户端！");
            }
            catch (IOException e)
            {
	            e.printStackTrace();
            }
			
		}
		
	}

}


客户端：
Java代码 复制代码 收藏代码27182216_A4aE.gif
  1. package net.tcp;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8. import java.net.Socket;
  10. public class Client extends Thread
  11. {
  13. Socket sk = null;
  14. BufferedReader reader = null;
  15. PrintWriter wtr = null;
  16. BufferedReader keyin = null;
  18. public Client()
  19. {
  20. keyin = new BufferedReader(new InputStreamReader(System.in));
  21. try
  22. {
  23. sk = new Socket("127.0.0.1", 1987);
  24. }
  25. catch (Exception e)
  26. {
  27. e.printStackTrace();
  28. }
  30. }
  32. public void run()
  33. {
  34. try
  35. {
  36. reader = new BufferedReader(new InputStreamReader(sk
  37. .getInputStream()));
  38. wtr = new PrintWriter(sk.getOutputStream());
  39. String get = keyin.readLine();
  41. while (true)
  42. {
  43. if (get != null & get.length() > 0)
  44. {
  45. wtr.println(get);
  46. wtr.flush();
  47. // wtr.close();
  48. // System.out.println(get + "发送完毕");
  49. }
  50. if (reader != null)
  51. {
  52. String line = reader.readLine();
  53. System.out.println("从服务器来的信息：" + line);
  55. }
  57. }
  58. }
  59. catch (Exception e)
  60. {
  61. e.printStackTrace();
  62. }
  63. }
  65. public static void main(String [] args)
  66. {
  67. new Client().start();
  68. }
  69. }

////////

1.服务端
package sterning;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.net. * ;
 import java.util.concurrent. * ;

 public class MultiThreadServer {
private int port=8821;
private ServerSocket serverSocket;
private ExecutorService executorService;//线程池
 private final int POOL_SIZE=10;//单个CPU线程池大小
public MultiThreadServer() throws IOException{
serverSocket=new ServerSocket(port);
//Runtime的availableProcessor()方法返回当前系统的CPU数目.
 executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);
System.out.println("服务器启动");
}

public void service(){
while(true){
Socket socket=null;
try {
//接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
 socket=serverSocket.accept();
executorService.execute(new Handler(socket));

} catch (Exception e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) throws IOException {
new MultiThreadServer().service();
}

}

class Handler implements Runnable {
private Socket socket;
public Handler(Socket socket){
this.socket=socket;
}
private PrintWriter getWriter(Socket socket) throws IOException{
OutputStream socketOut=socket.getOutputStream();
return new PrintWriter(socketOut,true);
}
private BufferedReader getReader(Socket socket) throws IOException{
InputStream socketIn=socket.getInputStream();
return new BufferedReader(new InputStreamReader(socketIn));
}
public String echo(String msg){
return "echo:"+msg;
}
public void run(){
try {
System.out.println("New connection accepted "+socket.getInetAddress()+":"+socket.getPort());
BufferedReader br=getReader(socket);
PrintWriter pw=getWriter(socket);
String msg=null;
while((msg=br.readLine())!=null){
System.out.println(msg);
pw.println(echo(msg));
if(msg.equals("bye"))
break;
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(socket!=null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

2.客户端
package sterning;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public class MultiThreadClient {

public static void main(String[] args) {
int numTasks = 10;

ExecutorService exec = Executors.newCachedThreadPool();

for (int i = 0; i < numTasks; i++) {
exec.execute(createTask(i));
}

}

// 定义一个简单的任务
 private static Runnable createTask(final int taskID) {
return new Runnable() {
private Socket socket = null;
private int port=8821;

public void run() {
System.out.println("Task " + taskID + ":start");
try {
socket = new Socket("localhost", port);
// 发送关闭命令
 OutputStream socketOut = socket.getOutputStream();
socketOut.write("shutdown\r\n".getBytes());

// 接收服务器的反馈
 BufferedReader br = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
String msg = null;
while ((msg = br.readLine()) != null)
System.out.println(msg);
} catch (IOException e) {
e.printStackTrace();
}
}

};
}
}

 

转载于:https://my.oschina.net/u/1398304/blog/337837

oldbalck
关注
如何在Java实现TCP方式发送和接收Socket消息（多线程模式）
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-19 9187
详细叙述了如何在Java实现TCP方式发送和接收Socket消息（多线程模式）。欢迎点赞收藏。
Java中的网络编程：如何高效实现多线程的Socket通信
微赚淘客系统开发者博客
08-14 1088
Socket允许程序在不同计算机之间通过网络进行通信。多线程Socket通信的基本思路是：服务器端在接受到客户端连接请求后，创建一个新的线程来处理该客户端的通信，从而使得服务器可以同时处理多个客户端连接。在本文中，我们将深入探讨如何在Java中实现多线程的Socket通信，并通过代码示例展示这种方法的实际应用。以下是一个简单的多线程Socket通信示例，演示如何使用Java实现一个支持多个客户端连接的服务器。当启动服务器并连接多个客户端时，服务器能够同时处理多个客户端的请求，并回显客户端发送的消息。
Java网络编程--多线程的Socket
u012369153的专栏
10-20 5574
Java中基于TCP UDP的Socket网络编程 多线程通话
socket 多线程 java_Java Socket 通信之多线程
weixin_28858229的博客
02-15 707
一、简单的客户端与服务器交互(客户端向服务器发送数据，服务器将数据再返回给客户端)服务端* 1、创建服务器 指定端口 ServerSocket(int port)* 2、接收客户端连接 阻塞时* 3、发送数据* 接收多个客户端Mulityserver.javapackagecn.Tcp;/** 服务端* 1、创建服务器 指定端口 ServerSocket(int port)* 2、接收客户...
socket使用多线程实现多客户端通信
Torey_Li的博客
04-02 1926
服务器端：package com.imooc;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;/* * 基于TCP协议的Socket通信，实现用户登录 * 服务器端 */public class SocketServer { public static void main(String[]...
【Java多线程、并发】创建线程的方式
qq_56949201的博客
04-03 499
*** 第二种创建线程的方式* 实现Runnable接口单独定义线程任务*///实例化任务//创建线程并指派任务t1.start();t2.start();i
Java Web项目中使用Socket通信多线程、长连接的方法
09-02
这里我们将深入探讨如何在Java Web环境中利用多线程和长连接技术实现Socket通信。 首先，为了在Web应用启动时初始化Socket监听，我们可以创建一个实现了`ServletContextListener`接口的类，如`AttendSocetListener`...
java多线程socket.pdf
10-07
java多线程socket.pdf
Java多线程-Socket编程
01-27
Java 多线程-Socket 编程是指在 Java 语言中使用多线程技术来实现网络编程，特别是使用 Socket 编程来实现客户端和服务器端的通信。在 Java 中，多线程可以使用 Thread 类和 Runnable 接口来实现，而 Socket 编程则...
基于Java多线程与Socket技术实现的GUI在线聊天室
最新发布
05-27
本项目是一个基于Java语言开发的在线聊天室，通过多线程与Socket技术实现了一个功能完备的图形界面（GUI）聊天平台。以下是该项目的关键知识点概述： 线程概念：Java中的线程是程序执行的基本单元，能够并行处理任务...
java模拟多线程socket通信
不忘初心的博客
03-01 4368
1.socket和serverSocket通信 socket和serverSocket通信简单介绍如下，注意客户端与服务器端是怎么交换数据的: 2.服务器端代码 package com.tl.skyLine.socket; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.
java多线程（2）---基于ExecutorService的socket通信线程池
hit100410628的博客
06-08 4740
了解线程池                socket通信，如果服务器端采用的实现方式是：一个客户端对应一个线程。那么，每个新线程都会消耗系统资源：创建一个线程会占用CPU周期，而且每个线程都会建立自己的数据结构（如，栈），也要消耗系统内存，另外，当一个线程阻塞时，JVM将保存其状态，选择另外一个线程运行，并在上下文转换（context switch）时恢复阻塞线程的状态。随着线程数的增加，
Java Socket（六） 使用多线程实现多客户端的通信
热门推荐
Mr.Phoebe的专栏
12-27 2万+
问题一个服务端可以跟多个客户端通讯基本步骤1.服务器端创建ServerSocket方法，循环调用accept()方法等待客户端连接2.客户端创建socket和服务的请求连接3.服务端接受客户端的请求，建立专线连接4.建立连接的两个socket在一个单独的线程上对话5.服务器端继续等待新的连接创建一个服务器相关的线程类：package com.test;/** * Created by SuPhoe
java socket 通讯和多线程结合的实例
信徒博客
10-02 4857
背景：矿山定位系统 实验器材：一个基站，15个手卡 运用知识点： sql批处理、socket通信、多线程 实验结果： 缺陷： 耗时长，15个手卡大约接受8个左右； 代码如下： package cn.com.project; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; ...
JAVA多线程Socket实现
Just do it
03-31 467
JAVA多线程Socket实现 代码简单实现客户询问10086客户个人账户套餐信息demo。代码主要分为客户端Client和服务端MultiThreadServer两个.java类。 服务端代码： package cn.thread.socket; import java.io.BufferedReader; import java.io.IOExcept
Java实现多线程Socket聊天系统
### Java多线程聊天程序知识点详解 ...总结起来，Java多线程聊天程序是一个典型且实用的并发编程和网络编程的练习项目，通过实现这样的程序，可以加深对Java多线程和Socket编程的理解和应用能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值