转自:http://developer.51cto.com/art/201003/190001.htm

Java Socket线程我们经常会用到的技术,但是有很多程序员还是有不少的使用问题,下面我们就看看如何才能进行有关的代码编写,希望大家又说收获。网络的伟大之一也是信息共享,Server可以主动向所有Client广播消息,同时Client也可以向其它Client发布消息。

下面看看如何开发一个可以实时传递消息的程序。

 import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.*;
public class Server extends ServerSocket
{
private static ArrayList User_List = new ArrayList();
private static ArrayList Threader = new ArrayList();
private static LinkedList Message_Array = new LinkedList();
private static int Thread_Counter = 0;
private static boolean isClear = true;
protected static final int SERVER_PORT = 10000;
protected FileOutputStream LOG_FILE = new FileOutputStream("d:/connect.log", true);
public Server() throws FileNotFoundException, IOException
{
super(SERVER_PORT);
new Broadcast();
//append connection log
Calendar now = Calendar.getInstance();
String str = "[" + now.getTime().toString() + "] Accepted a connection1512";
byte[] tmp = str.getBytes();
LOG_FILE.write(tmp);
try
{
while (true)
{
Socket socket = accept();
new CreateServerThread(socket);
}
}
finally
{
close();
}
}
public static void main(String[] args) throws IOException
{
new Server();
}
//--- Broadcast
class Broadcast extends Thread
{
public Broadcast()
{
start();
}
public void run()
{
while (true)
{
if (!isClear)
{
String tmp = (String)Message_Array.getFirst();
for (int i = 0; i < Threader.size(); i++)
{
CreateServerThread client = (CreateServerThread)Threader.get(i);
client.sendMessage(tmp);
}
Message_Array.removeFirst();
isClear = Message_Array.size() > 0 ? false : true;
}
}
}
}
//--- CreateServerThread
class CreateServerThread extends Thread
{
private Socket client;
private BufferedReader in;
private PrintWriter out;
private String Username;
public CreateServerThread(Socket s) throws IOException
{
client = s;
in = new BufferedReader(new InputStreamReader(client.getInputStream()));
out = new PrintWriter(client.getOutputStream(), true);
out.println("--- Welcome to this chatroom ---");
out.println("Input your nickname:");
start();
}
public void sendMessage(String msg)
{
out.println(msg);
}
public void run()
{
try
{
int flag = 0;
Thread_Counter++;
String line = in.readLine();
while (!line.equals("bye"))
{
if (line.equals("l"))
{
out.println(listOnlineUsers());
line = in.readLine();
continue;
}
if (flag++ == 0)
{
Username = line;
User_List.add(Username);
out.println(listOnlineUsers());
Threader.add(this);
pushMessage("[< " + Username + " come on in >]");
}
else
{
pushMessage("<" + Username + ">" + line);
}
line = in.readLine();
}
out.println("--- See you, bye! ---");
client.close();
}
catch (IOException e)
{}
finally
{
try
{
client.close();
}
catch (IOException e)
{}
Thread_Counter--;
Threader.remove(this);
User_List.remove(Username);
pushMessage("[< " + Username + " left>]");
}
}
private String listOnlineUsers()
{
String s ="-+- Online list -+-1512";
for (int i = 0; i < User_List.size(); i++)
{
s += "[" + User_List.get(i) + "]1512";
}
s += "-+---------------------+-";
return s;
}
private void pushMessage(String msg)
{
Message_Array.addLast(msg);
isClear = false;
}
}
}

以上就是对Java Socket线程的详细介绍。这就是程序运行后,多用户登陆并且输入信息后的屏幕。实现了信息的实时广播。用户输入"l"就可以列出在线人员表。

Java Socket线程的设计原理介绍

Java Socket线程如何才能更好的使用相关的技术应用呢?下面我们就看看如何才能更好的使用。希望大家有所收获。

作者:佚名来源:博客园|2010-03-19 17:47

Java Socket线程我们经常会用到的技术,但是有很多程序员还是有不少的使用问题,下面我们就看看如何才能进行有关的代码编写,希望大家又说收获。网络的伟大之一也是信息共享,Server可以主动向所有Client广播消息,同时Client也可以向其它Client发布消息。

下面看看如何开发一个可以实时传递消息的程序。

Java Socket线程的设计原理:

服务器端接受客户端的连接请求,同时启动一个线程处理这个连接,线程不停的读取客户端输入,然后把输入加入队列中,等候处理。在线程启动的同时将线程加入队列中,以便在需要的时候定位和取出。

{源码}

  1. import java.io.*;
  2. import java.net.*;
  3. import java.util.*;
  4. import java.lang.*;
  5. public class Server extends ServerSocket
  6. {
  7. private static ArrayList User_List = new ArrayList();
  8. private static ArrayList Threader = new ArrayList();
  9. private static LinkedList Message_Array = new LinkedList();
  10. private static int Thread_Counter = 0;
  11. private static boolean isClear = true;
  12. protected static final int SERVER_PORT = 10000;
  13. protected FileOutputStream LOG_FILE = new FileOutputStream("d:/connect.log", true);
  14. public Server() throws FileNotFoundException, IOException
  15. {
  16. super(SERVER_PORT);
  17. new Broadcast();
  18. //append connection log
  19. Calendar now = Calendar.getInstance();
  20. String str = "[" + now.getTime().toString() + "] Accepted a connection1512";
  21. byte[] tmp = str.getBytes();
  22. LOG_FILE.write(tmp);
  23. try
  24. {
  25. while (true)
  26. {
  27. Socket socket = accept();
  28. new CreateServerThread(socket);
  29. }
  30. }
  31. finally
  32. {
  33. close();
  34. }
  35. }
  36. public static void main(String[] args) throws IOException
  37. {
  38. new Server();
  39. }
  40. //--- Broadcast
  41. class Broadcast extends Thread
  42. {
  43. public Broadcast()
  44. {
  45. start();
  46. }
  47. public void run()
  48. {
  49. while (true)
  50. {
  51. if (!isClear)
  52. {
  53. String tmp = (String)Message_Array.getFirst();
  54. for (int i = 0; i < Threader.size(); i++)
  55. {
  56. CreateServerThread client = (CreateServerThread)Threader.get(i);
  57. client.sendMessage(tmp);
  58. }
  59. Message_Array.removeFirst();
  60. isClear = Message_Array.size() > 0 ? false : true;
  61. }
  62. }
  63. }
  64. }
  65. //--- CreateServerThread
  66. class CreateServerThread extends Thread
  67. {
  68. private Socket client;
  69. private BufferedReader in;
  70. private PrintWriter out;
  71. private String Username;
  72. public CreateServerThread(Socket s) throws IOException
  73. {
  74. client = s;
  75. in = new BufferedReader(new InputStreamReader(client.getInputStream()));
  76. out = new PrintWriter(client.getOutputStream(), true);
  77. out.println("--- Welcome to this chatroom ---");
  78. out.println("Input your nickname:");
  79. start();
  80. }
  81. public void sendMessage(String msg)
  82. {
  83. out.println(msg);
  84. }
  85. public void run()
  86. {
  87. try
  88. {
  89. int flag = 0;
  90. Thread_Counter++;
  91. String line = in.readLine();
  92. while (!line.equals("bye"))
  93. {
  94. if (line.equals("l"))
  95. {
  96. out.println(listOnlineUsers());
  97. line = in.readLine();
  98. continue;
  99. }
  100. if (flag++ == 0)
  101. {
  102. Username = line;
  103. User_List.add(Username);
  104. out.println(listOnlineUsers());
  105. Threader.add(this);
  106. pushMessage("[< " + Username + " come on in >]");
  107. }
  108. else
  109. {
  110. pushMessage("<" + Username + ">" + line);
  111. }
  112. line = in.readLine();
  113. }
  114. out.println("--- See you, bye! ---");
  115. client.close();
  116. }
  117. catch (IOException e)
  118. {}
  119. finally
  120. {
  121. try
  122. {
  123. client.close();
  124. }
  125. catch (IOException e)
  126. {}
  127. Thread_Counter--;
  128. Threader.remove(this);
  129. User_List.remove(Username);
  130. pushMessage("[< " + Username + " left>]");
  131. }
  132. }
  133. private String listOnlineUsers()
  134. {
  135. String s ="-+- Online list -+-1512";
  136. for (int i = 0; i < User_List.size(); i++)
  137. {
  138. s += "[" + User_List.get(i) + "]1512";
  139. }
  140. s += "-+---------------------+-";
  141. return s;
  142. }
  143. private void pushMessage(String msg)
  144. {
  145. Message_Array.addLast(msg);
  146. isClear = false;
  147. }
  148. }
  149. }

以上就是对Java Socket线程的详细介绍。这就是程序运行后,多用户登陆并且输入信息后的屏幕。实现了信息的实时广播。用户输入"l"就可以列出在线人员表。

Java Socket线程的设计原理介绍的更多相关文章

  1. Java进阶——— 线程池的原理分析

    前言 在了解线程池之前,其实首先出现的疑问是:为什么要使用线程池,其次是了解什么是线程池,最后是如何使用线程池,带着疑问去学习. 为什么要使用 前面多线程文章中,需要使用线程就开启一个新线程,简单方便 ...

  2. java socket线程通信

    关于socket线程通信的一些知识整理 一般我们需要要让两台机子进行通信,需要创建一个Server 类,一个Client类,还需要创建一个线程类 server public class Server ...

  3. Java - "JUC线程池" ThreadPoolExecutor原理解析

    Java多线程系列--“JUC线程池”02之 线程池原理(一) ThreadPoolExecutor简介 ThreadPoolExecutor是线程池类.对于线程池,可以通俗的将它理解为"存 ...

  4. java中的String设计原理

    首先,必须强调一点:String Pool不是在堆区,也不是在栈区,而是存在于方法区(Method Area) 解析: String Pool是常量池(Constant  Pool)中的一块. 我们知 ...

  5. 谈谈Java的线程池设计

    在实际项目中,如果因为想异步执行暂时性的任务而不断创建线程是很浪费资源的事情(当一个任务执行完后,线程也没用了).这种情况下,最好是将任务提交给线程池执行. 所谓池,就是将管理某一种资源,对资源进行复 ...

  6. kafka设计原理介绍

    背景介绍 Kafka简介 Kafka是一种分布式的,基于发布/订阅的消息系统.主要设计目标如下: 以时间复杂度为O(1)的方式提供消息持久化能力,即使对TB级以上数据也能保证常数时间的访问性能 高吞吐 ...

  7. Java Socket编程如何建立两者关系

    转自:http://developer.51cto.com/art/201003/190582.htm Java Socket编程需要大家详细的学习,有关的技术一直在不断的更新.那么要如何才能掌握好有 ...

  8. Java线程池的原理及几类线程池的介绍

    刚刚研究了一下线程池,如果有不足之处,请大家不吝赐教,大家共同学习.共同交流. 在什么情况下使用线程池? 单个任务处理的时间比较短 将需处理的任务的数量大 使用线程池的好处: 减少在创建和销毁线程上所 ...

  9. Java[4] Jetty工作原理介绍(转)

    转自:https://www.ibm.com/developerworks/cn/java/j-lo-jetty/ Jetty 的工作原理以及与 Tomcat 的比较 Jetty 应该是目前最活跃也是 ...

随机推荐

  1. [APIO2012] 派遣 dispatching

    Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 4580  Solved: 2348 Description 在一个忍者的帮派里,一些忍者们被选中派遣给 ...

  2. [Vijos] 天才的记忆

    背景 神仙飞啊飞 描述 从前有个人名叫W and N and B,他有着天才般的记忆力,他珍藏了许多许多的宝藏.在他离世之后留给后人一个难题(专门考验记忆力的啊!),如果谁能轻松回答出这个问题,便可以 ...

  3. 使用Spring定时任务并且通过AOP监控任务执行情况

    原文:http://www.open-open.com/code/view/1426250803279 本文讲的是通过Spring注解的方式实现任务调度.只要引入了spring-context包就能够 ...

  4. 【effective c++】模板与泛型编程

    模板元编程:在c++编译器内执行并于编译完成时停止执行 1.了解隐式接口和编译期多态 面向对象编程总是以显式接口(由函数名称.参数类型和返回类型构成)和运行期多态(虚函数)解决问题 模板及泛型编程:对 ...

  5. C++中防止STL中迭代器失效——map/set等关联容器——vector/list/deque等序列容器—如何防止迭代器失效—即erase()的使用

    序列性容器::(vector和list和deque)   erase迭代器不仅使所有指向被删元素的迭代器失效,而且使被   删元素之后的所有迭代器失效,所以不能使用erase(iter++)的方 式, ...

  6. HDU 5288(OO’s Sequence-区间互质情况统计)

    OO's Sequence Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) ...

  7. 工作总结 js 选择器选择多条元素 支持一起设置他们属性 $("#edumes input[type='radio']").prop("checked", false);

    $("#edumes input[type='radio']").prop("checked", false); $("#edumes input[t ...

  8. ASP.NET没有魔法——ASP.NET MVC Razor与View渲染 ASP.NET没有魔法——ASP.NET MVC界面美化及使用Bundle完成静态资源管理

    ASP.NET没有魔法——ASP.NET MVC Razor与View渲染   对于Web应用来说,它的界面是由浏览器根据HTML代码及其引用的相关资源进行渲染后展示给用户的结果,换句话说Web应用的 ...

  9. CSS制作翻牌特效

    应一个朋友要求替他把原本静态页面做成翻牌的特效. 主要应用了CSS3的transform,transiton.首先写好标签,一个ul下两个li元素,通过position的absolue设置两个li元素 ...

  10. windows内存管理的机制以及优缺点

    分页存储管理基本思想:用户程序的地址空间被划分成若干固定大小的区域,称为“页”,相应地,内存空间分成若干个物理块,页和块的大小相等.可将用户程序的任一页放在内存的任一块中,实现了离散分配. 分段存储管 ...