分布式学习（一）

最新推荐文章于 2022-09-06 18:29:30 发布
最新推荐文章于 2022-09-06 18:29:30 发布
阅读量565 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sunxing2016/article/details/43303241
这个分布式主要实现的功能是将数据库中的需要下载的url从数据库中读取出来，同时server端通过将其中的数据读取出来后，同时将每一个对象发送给客户端
     服务端分为：       数据分发，连接处理，以及连接检测和server主类共四个部分
     客户端主要分为:   数据处理，连接检测以及客户端主类等三个部分
     数据库部分分为： 数据库操作，对象封装，线程读取等三个部分
     实体类分为：       待下载url的字段属性封装类，客户端链接实体类等两个实体类
     工具类分为：       json处理类
     接口分为:            传输数据实体类接口，客户端数据接受接口

分布式功能描述：
1：数据读取线程通过数据库操作将读取到的数据库内容通过调用json操作类使用反射机制来实现数据库数据封装到对象，同时将对象放入到缓存中等待服务端读取。
message接口是用来实现多个对象的基层这个接口来实现上转型传递，在客户端通过Message msg = (Message )obj;
这个地方也不是很好，这是自己个人的一个小想法就这么写了。下面那个是实体类
public interface Message extends Serializable{
}
public class NeedFetchUrl implements Message{
      private long _id;
      private String url;
      private String title;
      private String boardUrl;
      private long hostId;
      private long fetchTime;
      private int status;
      private int type;
      private int dynamic;
      private int foreign;
      private int siteWeight;
      private String address;
      private String host;
      private int boardDeep;
      private int contentType;
}
数据库操作类，主要是通过针对底层的一个简单封装，方便数据看操作，MongoDB主要是封装数据库链接，数据库查询删除等操作的操作，MongoFactory主要用于封装MongoDB提供方便操作，同时通过反射来实现对象的初始化
public class MongoDB {
      /**
      * 数据库所在机器地址
      */
      private String ip;
      /**
      * 数据库名称
      */
      private String dbName;
      /**
      * 端口
      */
      private int port;
      /**
      * 数据库连接对象
      */
      private DB db;
      /**
      * 构造函数
      * 作者： Sunx
      * @param ip
      * @param dbName
      * @param port
      */
      public MongoDB(String ip, int port,String dbName){
            this. ip = ip;
            this. dbName = dbName;
            this. port = port;
            //初始化 db连接对象
           getDB();
     }
      /**
      * 方法名：getDB
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 9:39:19 AM
      * 描述：获取数据库连接对象
      * @return
      */
      public void getDB(){
            try {
                DBAddress address = new DBAddress( ip, port, dbName);
                DB db2 = MongoClient. connect(address);
                 db = db2;
           } catch (UnknownHostException e) {
                e.printStackTrace();
           }
     }
      /**
      * 方法名：findAll
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 9:46:57 AM
      * 描述：查询某一张表的所有数据
      */
      public void findAll(String tableName){
            //获取操作表的对象
           DBCollection table = db.getCollection(tableName);
           DBCursor cur = table.find();
            while (cur.hasNext()) {
                System. out.println(cur.next());
           }
     }
      /**
      * 方法名：find
      * 作者： Sunx
      * 创建时间： Oct 13, 2014 2:12:54 PM
      * 描述：根据条件从数据库中查询数据
      * @param tableName
      * @param keys
      * @param values
      * @return
      */
      public List<DBObject> find(String tableName,String[]keys,Object[] values){
            //获取操作表的对象
           DBCollection table = db.getCollection(tableName);
           DBObject query = put(keys, values);
            //获取查询结果
           DBCursor curs = table.find(query);
           List<DBObject> temp = new ArrayList<DBObject>();
            for(DBObject obj : curs.toArray()){
                temp.add(obj);
           }
           
            return temp;
     }
      /**
      * 方法名：update
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 10:54:23 AM
      * 描述：更新数据库中字段
      * @param keys
      * @param values
      * @param newKeys
      * @param newValues
      */
      public void update(String tableName,String[]keys,Object[] values,String[]newKeys,Object[] newValues){
            //获取操作表的数据信息
           DBCollection curs = db.getCollection(tableName);
            //创建插入数据对象
           DBObject oldObj = put(keys, values);
           DBObject temp = put(newKeys, newValues);
           DBObject newObj = new BasicDBObject( "$set",temp);
            //执行更新
           curs.update(oldObj,newObj, false, true);
     }
      /**
      * 方法名：insert
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 10:54:37 AM
      * 描述：向数据库中插入数据信息
      */
      public boolean insert(String tableName,String[] keys,Object[]values){
            //获取操作表的数据信息
           DBCollection curs = db.getCollection(tableName);
           DBObject obj = put(keys, values);
            //将数据信息保存到数据库中
            try{
                WriteResult result = curs.insert(obj);
                 return (result.getError() != null)  ? false : true;
           } catch (MongoException e) {
                e.printStackTrace();
           }
            return false;
     }
      /**
      * 方法名：delete
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 1:54:47 PM
      * 描述：根据条件删除数据信息
      * @param tableName
      * @param keys
      * @param values
      */
      public void delete(String tableName,String[] keys,Object[]values){
            //获取操作表的数据信息
           DBCollection curs = db.getCollection(tableName);
           DBObject obj = put(keys, values);
           curs.remove(obj);
     }
      /**
      * 方法名：isExits
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 2:21:30 PM
      * 描述：查询是否已经存在
      * @param tableName
      * @param keys
      * @param values
      * @return
      */
      public boolean isExits(String tableName,String[] keys,Object[]values){
            //获取操作表的对象
           DBCollection table = db.getCollection(tableName);
           DBObject query = put(keys, values);
            //获取查询结果
           DBCursor curs = table.find(query);
           List<DBObject> temp = curs.toArray();
            if(temp.size() <= 0) return true;
            return false;
     }
      /**
      * 方法名：execute
      * 作者： Sunx
      * 创建时间： Oct 9, 2014 1:55:46 PM
      * 描述：获取数据信息
      * @param tableName
      * @param keys
      * @param values
      * @return
      */
      public DBObject put(String[] keys,Object[]values){
            //创建插入数据对象
           DBObject obj = new BasicDBObject();
            //封装要插入的数据信息
            for( int i=0;i<keys. length;i++){
                obj.put(keys[i], values[i]);
           }
            //返回对象
            return obj;
     }
}
public class MongoFactory {
      /**
      * 数据库操作对象
      */
      private MongoDB mongo;
      /**
      * 将字符串解析为对象格式
      */
      private JSONObject json;
      /**
      * 构造函数
      * 作者： Sunx
      *         初始化参数
      */
      public MongoFactory(){
            mongo = new MongoDB(Contant.MONGO_IP ,Contant.MONGO_DB_PORT ,Contant. MONGO_DB_NAME);
            json = new JSONObject();
     }
      /**
      * 方法名：get
      * 作者： Sunx
      * 创建时间： Oct 13, 2014 2:08:12 PM
      * 描述：从数据库中读取数据
      * @param <T>
      * @return
      */
      public <T> List<T> find(String tableName,String[] keys,Object[] values,Class bean){
           List<DBObject> curs = mongo.find(tableName, keys, values);
           List<T> result = json.parser(curs,bean);
            return result;
     }
      /**
      * 方法名：get
      * 作者： Sunx
      * 创建时间： Oct 13, 2014 2:22:58 PM
      * 描述：从数据库中读取数据
      * @param <T>
      * @param tableName
      * @param keys
      * @param values
      * @param bean
      * @param num
      * @return
      */
      public <T> List<T> find(String tableName,String[] keys,Object[] values,Class bean,int num){
           List<DBObject> curs = mongo.find(tableName, keys, values);
            if(curs == null || curs.size() <= 0) return null;
            int temp = num > curs.size()?curs.size():num;
           curs = curs.subList(0,temp);
           List<T> result = json.parser(curs,bean);
            return result;
     }
      /**
      * 方法名：update
      * 作者： Sunx
      * 创建时间： Oct 13, 2014 2:35:22 PM
      * 描述：更新字段
      * @param tableName
      * @param keys
      * @param values
      * @param newKeys
      * @param newValues
      */
      public void update(String tableName,String[] keys,Object[] values,String[] newKeys,Object[] newValues){
            mongo.update(tableName, keys, values, newKeys, newValues);
     }
      /**
      * 方法名：isExits
      * 作者： Sunx
      * 创建时间： Oct 13, 2014 2:39:42 PM
      * 描述：查询数据是否在数据库中已经存在
      * @param tableName
      * @param keys
      * @param values
      * @return
      */
      public boolean isExits(String tableName,String[] keys,Object[] values){
            return mongo.isExits(tableName, keys, values);
     }
      /**
      * 方法名：main
      * 作者： wangerkang
      * 创建时间：2014 -10 -31 下午06:14:41
      * 描述：
      * @param args
      */
      public static void main(String[] args) {
           MongoFactory factory = new MongoFactory();
           List<Board> list = factory.find(Contant.MONGO_BOARD_TABLE_NAME , new String[]{"type" }, new Object[]{1}, Board. class);
           System. err.println(list.size());
     }
}
public class JSONObject {
      /**
      * 方法名：parser
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 10:37:08 AM
      * 描述：解析查询出来的结果,并将其转化为对象
      * @param tt
      * @param bean
      * @return
      */
      public <T> List<T> parser(List<DBObject> list,Class bean){
            //创建返回集合
           List<T> temp = new ArrayList<T>();
            //遍历集合
            for(DBObject dbObj : list){
                T result = (T)toNewBean(dbObj.toMap(), dbObj.keySet(), bean);
                temp.add(result);
           }
            return temp;
     }
      /**
      * 方法名：toNewBean
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:57:16 AM
      * 描述：字段对应的名称已经有了，查询bean中找到相应的属性值，同时在map中找到相应的属性对应的值
      * @param map
      * @param keys
      * @param bean
      * @return
      */
      public Object toNewBean(Map map,Set<String> keys,Class bean){
            boolean bool = true;
            try {
                 //创建对象
                Object obj = bean.newInstance();
                 for(String str : keys){
                      //获取属性
                     Field field = bean.getDeclaredField(str);
                      if(field == null){
                           bool = false;
                            break;
                     }
                     field.setAccessible( true);
                      //获取属性值
                      if(!map.containsKey(str)){
                           bool = false;
                            break;
                     }
                     Object value = map.get(str);
                      //设置属性值
                     setValue(field,obj,value);
                }
                 if(bool) return obj;
           } catch (SecurityException e) {
                e.printStackTrace();
           } catch (NoSuchFieldException e) {
                e.printStackTrace();
           } catch (InstantiationException e) {
                e.printStackTrace();
           } catch (IllegalAccessException e) {
                e.printStackTrace();
           }
            return null;
     }
      /**
      * 方法名：setValue
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:48:37 AM
      * 描述：设置参数值
      * @param field
      * @param obj
      * @param value
      * @return
      */
      public Field setValue(Field field,Object obj,Object value){
            try {
                 if(field.getType().toString().contains( "int")){
                      int t = getInt(value.toString());
                     field.set(obj, t);
                } else if(field.getType().toString().contains( "long")){
                      long t = getLong(value.toString());
                     field.set(obj, t);
                } else if(field.getType().toString().contains( "float")){
                      float t = getFloat(value.toString());
                     field.set(obj, t);
                } else if(field.getType().toString().contains( "double")){
                      double t = getDouble(value.toString());
                     field.set(obj, t);
                } else if(field.getType().toString().contains( "char")){
                      char t = getChar(value.toString());
                     field.set(obj, t);
                } else if(field.getType().toString().contains( "String")){
                     field.set(obj, value.toString());
                } else if(field.getType().toString().contains( "boolean")){
                      boolean bool  = getBoolean(value.toString());
                     field.set(obj, bool);
                }
           } catch (IllegalArgumentException e) {
                e.printStackTrace();
           } catch (IllegalAccessException e) {
                e.printStackTrace();
           }
            return field;
     }
      /**
      * 方法名：getInt
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:48:12 AM
      * 描述：获取 int值
      * @param value
      * @return
      */
      public int getInt(String value){
            int t = 0;
            try {
                 if(value.contains( ".")){
                     t = ( int)Double. parseDouble(value);
                } else{
                     t = Integer. parseInt(value);
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
            return t;
     }
      /**
      * 方法名：getLong
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:48:08 AM
      * 描述：获取long值
      * @param value
      * @return
      */
      public long getLong(String value){
            long t = 0;
            try {
                 if(value.contains( ".")){
                     t = ( int)Double. parseDouble(value);
                } else{
                     t = Long. parseLong(value);
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
            return t;
     }
      /**
      * 方法名：getFloat
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:47:53 AM
      * 描述：获取float值
      * @param value
      * @return
      */
      public float getFloat(String value){
            try {
                 return Float. parseFloat(value);
           } catch (Exception e) {
                e.printStackTrace();
           }
            return 0;
     }
      /**
      * 方法名：getDouble
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:47:38 AM
      * 描述：获取double值
      * @param value
      * @return
      */
      public double getDouble(String value){
            try {
                 return Double. parseDouble(value);
           } catch (Exception e) {
                e.printStackTrace();
           }
            return 0;
     }
      /**
      * 方法名：getChar
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:47:13 AM
      * 描述：获取char值
      * @param value
      * @return
      */
      public char getChar(String value){
         if(value.length() < 0 || value == null) return '0';
            return value.charAt(0);
     }
      /**
      * 方法名：getBoolean
      * 作者： Sunx
      * 创建时间： Oct 11, 2014 9:46:18 AM
      * 描述：获取Boolean值
      * @param value
      * @return
      */
      public boolean getBoolean(String value){
            if(value.contains( "true") || value.contains("True" ))return true;
            return false;
     }
}


通过数据库操作的封装后，下面要做的就是通过现场来读取数据将其放入到缓存中以便给服务端获取数据，数据读取线程通过继承Runnable接口来实现线程任务的，针对实现Runnable接口，主要是Runnbale接口的出现时针对线程任务的，实现了任务的对象封装，同时java中是单继承的，不用因继承了某个类而不能再继承其他类了
public class GetUrl implements Runnable{
      private List<NeedFetchUrl> list;
      private Set<String> cache;
     
      private MongoFactory factory;
      /**
      * 构造函数
      * 作者：Administrator
      */
      public GetUrl(){
            list = new LinkedList<NeedFetchUrl>();
            cache = new HashSet<String>();
           
            factory = new MongoFactory();
     }
     
      @Override
      public void run() {
            while( true){
                 try {
                     System. err.println( "start to get url from db ...");
                     List<NeedFetchUrl> list = factory.find(Contant. MONGO_URL_TABLE_NAME , new   String[]{"status" }, new Object[]{0}, NeedFetchUrl. class);
                      if(list == null || list.size() <= 0){
                           Thread. sleep(1000 * 60);
                            continue;
                     }
                     set(list);
                     Thread. sleep(1000 * 60);
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public synchronized void set(List<NeedFetchUrl> list){
            try {
                 int j = 0;
                 for( int i=0;i<list.size();i++){
                      if(! cache.contains(list.get(i).getUrl())){
                            this. list.add(list.get(i));
                            cache.add(list.get(i).getUrl());
                           j++;
                     }
                }
                System. out.println( "wait add url to cache,add.size:" + j);
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      public synchronized NeedFetchUrl get(){
           NeedFetchUrl  need = null;
            try {
                System. out.println( list.size());
                 if(! list.isEmpty()){
                     need = list.remove(0);
                      cache.remove(need.getUrl());
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
            return need;
     }
      public static void main(String[] args) {
           GetUrl getUrl = new GetUrl();
           Thread tt = new Thread(getUrl);
           tt.start();
     }
}

2：服务端读取对象以后，由于该对象继承了数据传输接口，针对不同的类只要实现这个接口就行，服务端分发这个接类对象，在客户端通过上转型来接受传递过来的对象，然后判断实际的类型。在这个分布式代码中没有这么做，因为这个事第一版，只是分发一个对象就没有写这个复杂。
3：服务端通过绑定数据分发线程，连接检测线程以及连接接收线程等部分来实现程序的调用，数据分发线程从数据读取线程中的缓存中拿去一个对象，通过服务端主类获取客户端链接缓存队列，遍历队列将队列中的客户端链接读取出来，判断客户端状态，如果客户端状态为1，表示该客户端已经处于离线状态或者是当时网络处于堵塞状态，那么这次就不会发送数据给该客户端，如果客户端状态为0，则将该对象发送过去。
链接检测线程：如果链接五次都没有链接上该客户端，那么认定这个客户端已经失效，服务端丢弃掉这个客户端。链接检测线程通过向客户端发送心跳包的形式来检测客户端是否还处于正常状态，同样在win7系统中发送心跳包17次以后，操作系统底层会强制将该socket该关闭掉，那么这个时候链接就会中断。链接检测线程就会重新链接服务端，在这个过程中可以将以前的客户端的端口绑定到重新链接服务端的socket上，针对这个想法做了一个实现，如果这个时候没有链接上主机，从而导致在下载再次链接时报该端口已经被占用，这个是我代码里面的一个小错误，在下面会优化
服务端的主类代码：
public class Server{
      private Map<String,Connection> map;
     
      private ServerHandler serverHandler;
      private AcceptHandler acceptHandler;
      private CheckHandler checkHandler;
     
      public Server(){
            map = new HashMap<String,Connection>();
     }
      public Map<String,Connection> getMap() {
            return map;
     }
      public synchronized void setList(Connection conn){
            if( map.containsKey(conn.getId())){
                 map.get(conn.getId()).setStatus(0);
                 map.get(conn.getNum()).setNum(0);
           } else{
                 map.put(conn.getId(), conn);
           }
     }
      public synchronized void remove(Connection conn){
            if( map.containsKey(conn.getId())){
                 map.remove(conn.getId());
           }
     }
      //绑定分发url机制
      public void setServerHandler(ServerHandler serverHadler){
            this. serverHandler = serverHadler;
            this. serverHandler.setServer( this);
            //启动url 分发服务器
           Thread t = new Thread( this. serverHandler);
           t.start();
     }
      public void setAcceptHandler(AcceptHandler acceptHandler){
            this. acceptHandler = acceptHandler;
            this. acceptHandler.setServer( this);
            //启动连接检测线程
           acceptHandler.runAccept();
           Thread tt = new Thread( this. acceptHandler);
           tt.start();
     }
      public void steCheckHandler(CheckHandler checkHandler){
            this. checkHandler = checkHandler;
            this. checkHandler.setServer( this);
            //启动连接检测线程
           Thread tt = new Thread( this. checkHandler);
           tt.start();
     }
      public void runServer(){
     }
      public static void main(String[] args) {
            //启动数据读取线程
           GetUrl getUrl = new GetUrl();
           Thread tt = new Thread(getUrl);
           tt.start();
            //启动server
           Server server = new Server();
            //为server绑定数据分发线程
           server.setServerHandler( new ServerHandler(getUrl));
            //为server绑定链接检测线程
           server.steCheckHandler( new CheckHandler());
            //为server绑定接受连接线程
           server.setAcceptHandler( new AcceptHandler(10000));
            //运行server
           server.runServer();
     }
}

服务端主类代码中主要是给服务端绑定各种处理机制，分发线程，检测线程以及连接线程等。下面是代码实现：

public class ServerHandler implements Runnable{
      private GetUrl getUrl;
      private Server server;
     
      public ServerHandler(GetUrl getUrl){
            this. getUrl = getUrl;
     }
     
      public void setServer(Server server){
            this. server = server;
     }
     
      @Override
      public void run() {
           NeedFetchUrl need = null;
            while( true){
                 try {
                     System. err.println( "server handler start...");
                      if( server == null){
                           System. err.println( "server handler to init server error");
                            break;
                     }
                     need = getUrl.get();
                      if(need == null){
                           System. err.println( "server handler to get url error");
                           Thread. sleep(1000 * 1);
                            continue;
                     }
                     sendData(need);
                     Thread. sleep(1000 * 10);
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public void sendData(List<NeedFetchUrl> needs){
           sendDataToClient(needs);
     }
      public void sendData(NeedFetchUrl need){
           sendDataToClient(need);
     }
      public <T> void sendDataToClient(T t){
            try {
                Map<String,Connection> map = server.getMap();
                 if(map == null || map.size() <= 0){
                     System. err.println( "没有客户端到服务器..." );
                      return;
                }
                 for(Entry<String, Connection> entry  : map.entrySet()){
                     sendData(entry.getValue(),t);
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      public void sendData(Connection conn,Object obj){
           ObjectOutputStream oos = null;
            try {
                oos = getWriter(conn);
                 if(oos == null){
                     System. err.println( "客户端链接已经丢失,等待重新链接..." );
                      return;
                }
                oos.writeObject(obj);
                oos.flush();
                System. err.println( "send to client data:" + obj.toString());
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
     
      public ObjectOutputStream getWriter(Connection conn) throws Exception{
            if(conn.getStatus() == 1) return null;
            return new ObjectOutputStream(conn.getSocket().getOutputStream());
     }
     
      public static void main(String[] args) {
            //启动数据读取线程
           GetUrl getUrl = new GetUrl();
           Thread tt = new Thread(getUrl);
           tt.start();
            //
           ServerHandler serverHandler = new ServerHandler(getUrl);
            //启动url 分发服务器
           Thread t = new Thread(serverHandler);
           t.start();
     }
}

下面是链接检测线程:
public class CheckHandler implements Runnable{
      private Server server;
     
      public void setServer(Server server){
            this. server = server;
     }
      @Override
      public void run() {
            while( true){
                 try {
                     System. err.println( "checkHandler");
                      //获取所有链接
                     check();
                     Thread. sleep(1000 * 2);
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public void check(){
            try {
                Map<String,Connection> map = server.getMap();
                 if(map == null || map.size() <= 0){
                     System. err.println( "没有客户端到服务器..." );
                      return;
                }
                 for(Entry<String, Connection> entry  : map.entrySet()){
                      //判断这个客户端是否已经挂了
                      if(entry.getValue().getStatus() != 0){
                           System. err.println( "客户端已经处于离线状态,等待下次链接:" + entry.getKey() + "\t该客户端的num:" + entry.getValue().getNum());
                            if(entry.getValue().getStatus() == 1 && entry.getValue().getNum() >= 5){
                                 //移除该客户端
                                 server.remove(entry.getValue());
                                System. err.println( "客户端链接次数超过限制,系统决定移除该客户端:" + entry.getKey());
                                 continue;
                           }
                     }
                     check(entry.getValue());
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      public void check(Connection conn){
            try {
                System. err.println( "检测客户端是否连接：" + conn.getId());
                conn.getSocket().sendUrgentData(0xff);
                setRig(conn);
           } catch (Exception e) {
                e.printStackTrace();
                 //这个地方报错,说明客户端与服务端链接不正常
                setErr(conn);
           }
     }
      public void setRig(Connection conn){
            if(conn.getStatus() != 0){
                conn.setStatus(0);
                conn.setNum(0);
           }
     }
      public void setErr(Connection conn){
            if(conn.getStatus() == 1 && conn.getNum() > 5){
                 //移除该客户端
                 server.remove(conn);
           } else{
                conn.setStatus(1);
                conn.setNum(conn.getNum() + 1);
           }
     }
}
接收连接线程:
public class AcceptHandler implements Runnable{
      private ServerSocket serverSocket;
      private int port;
      private Server server;
     
      public AcceptHandler( int port){
            this. port = port;
     }
      public void setServer(Server server){
            this. server = server;
     }
     
      @Override
      public void run() {
            //监听连接
            while( true){
                 try {
                     System. err.println( "wait to client to connecte...");
                     Socket socket = serverSocket.accept();
                      //封装连接,将连接存储到缓存中
                     Connection conn = new Connection();
                     conn.setSocket(socket);
                     conn.setStatus(0);
                     conn.setId(socket.getInetAddress().getHostAddress() + "/" + socket.getPort());
                     conn.setNum(0);
                      //将连接对象存储到缓存中
                      server.setList(conn);
                     System. err.println( "a new client to connecte the server,client.ip:" + socket.getInetAddress().getHostAddress());
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public void runAccept(){
            try {
                 serverSocket = new ServerSocket( port);
//              accept();
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      public void accept(){
            //监听连接
            while( true){
                 try {
                     System. err.println( "wait to client to connecte...");
                     Socket socket = serverSocket.accept();
                      //封装连接,将连接存储到缓存中
                     Connection conn = new Connection();
                     conn.setSocket(socket);
                     conn.setStatus(0);
                     conn.setId(socket.getInetAddress().getHostAddress());
                     conn.setNum(0);
                      //将连接对象存储到缓存中
                      server.setList(conn);
                     System. err.println( "a new client to connecte the server,client.ip:" + socket.getInetAddress().getHostAddress());
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
     
}


4：客户端通过数据处理线程来接收服务端发送过来的对象，并将对象中的信息打印出来，通过链接检测线程来实现客户端与服务端的连接

客户端主类:
public class Client {
      private Socket socket;
      private DataHandler dataHandler;
      private ClientCheckHandler checkHandler;
     
      public Socket getSocket(){
            return socket;
     }
      public void setSocket(Socket socket){
            this. socket = socket;
     }
      //绑定主机
      public void bind(String host, int port){
            try {
                 socket = new Socket(host,port);
                 socket.setKeepAlive( true);
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      //绑定数据接受线程
      public void setDataHandler(DataHandler dataHandler){
            this. dataHandler = dataHandler;
            this. dataHandler.setClient( this);
     }
      //
      public void setCheckHandler(ClientCheckHandler checkHandler){
            this. checkHandler = checkHandler;
            this. checkHandler.setClient( this);
     }
      public void runClient(){
           Thread t = new Thread( dataHandler);
           t.start();
           
           Thread tt = new Thread( checkHandler);
           tt.start();
     }
      public static void main(String[] args) {
           Client client = new Client();
            //给客户端绑定服务器
           client.bind( "192.168.1.103",10000);
            //给客户端绑定数据接受器
           client.setDataHandler( new ClientDataHandler());
            //客户端链接检测线程
           client.setCheckHandler( new ClientCheckHandler());
            //运行客户端
           client.runClient();
     }
}

客户端链接检测线程：
public class ClientCheckHandler implements Runnable{
      private Client client;
     
      public void setClient(Client client){
            this. client = client;
     }
      @Override
      public void run() {
            while( true){
                 try {
                     check();
                     Thread. sleep(1000 * 2);
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public void check(){
            try {
                 client.getSocket().sendUrgentData(0xff);
           } catch (Exception e) {
                e.printStackTrace();
                System. err.println( "客户端与主机链接异常,将重新链接主机..." );
                 try {
//                   InetAddress inetAddr = InetAddress.getLocalHost();
                     Socket socket = new Socket(
                                      client.getSocket().getInetAddress().getHostAddress(),
                                      client.getSocket().getPort()
//                                   inetAddr,
//                                   client.getSocket().getLocalPort()
                                     );
                      client.setSocket(socket);
                     System. err.println( "客户端重新链接上主机,客户端信息为:" + socket.getLocalAddress().getHostAddress() + "/" + socket.getLocalPort());
                } catch (UnknownHostException e1) {
                     e1.printStackTrace();
                } catch (IOException e1) {
                     e1.printStackTrace();
                }
           }
     }
}

客户端数据接受线程：

public class ClientDataHandler implements DataHandler{
      private Client client;
     
      @Override
      public void setClient(Client client) {
            this. client = client;
     }
     
      @Override
      public void run() {
            while( true){
                 try {
                     Socket socket = client.getSocket();
                      if(socket == null){
                           System. err.println( "client to get socket error");
                           Thread. sleep(1000);
                            continue;
                     }
                     getData(socket);
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
      public void getData(Socket socket){
            try {
                ObjectInputStream ois = getReader(socket);
                 if(ois == null) return;
                Object obj = ois.readObject();
                System. err.println( "client接受到的数据为:" + obj.toString());
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
      public ObjectInputStream getReader(Socket socket) throws Exception{
            if(socket.getInputStream().available() < 1) return null;
            return new ObjectInputStream(socket.getInputStream());
     }
}



个人能力有限，这个还有待改进...


分布式机器学习\分布式KMeans
m0_59082440的博客
10-22 1242
1.分布式机器学习 以线性回归模型的优化为例来展示在分布式机器学习中模型的训练过程。模型表示为： 损失函数可以表示为: 利用梯度下降算法进行参数优化，先对损失函数求一阶偏导数，即 得到所有样本的梯度的总和，从上述公式可以看出每个样本的对应的梯度为，在第步下的参数的更新：, 由上述计算梯度的公式可知道，优化过程的效率与样本量和参数个数有关，因此如果将梯度计算并行化，优化效率将得到提升。 在分布式系统中一般要考虑通信开销和同步开销。以clien...
深度学习——分布式训练
千禧皓月的博客
08-27 1641
最近开始上手进行分布式训练，于是在网上开始搜各种教程和资料，看到了许多写得很好的文章，但是有些文章又不是特别的全面，于是决定对这些文章进行归纳和总结，方便后来者的学习和查阅。这里友情提醒一下，大家查资料的时候不要仅仅局限于百度，有时候在百度上查半天，不如去官方文档或者google搜一下，立马就能看到很多优质的解答。
分布式架构学习之：018--Dubbo集群
熊诗言的博客
05-12 1143
dubbo服务集群常用配置  服务提供者  Xml代码   dubbo:application name="pay-service-trade" />                 dubbo:registry protocol="zookeeper" address="${dubbo.registry.address}" />          dubbo:
初识Dubbo 系列之9-Dubbo 负载均衡
p0p0p0p01的专栏
04-29 3089
初识Dubbo 系列之9-Dubbo 负载均衡
分布式学习-总结
dreamzuora的博客
04-21 2226
分布式理论 分布式系统定义以及面临的问题 分布式系统定义 分布式系统是一个硬件或软件组件分布在不同的网路计算机上，彼此之间仅仅通过消息传递进行通信和协调的系统。 分布式面临的问题 通信异常 由于网络本身的不可靠性，出现消息丢失、消息延迟 网络分区 由于网络发生异常情况，导致分布式系统中部分节点之间的网络延迟不断增大，最终导致组成分布式系统中有部分节点能够正常通信，网络之间出现了网络不连通，但各...
分布式机器学习
武天旭的博客
03-08 6832
一、分布式机器学习定义 分布式机器学习（DML）是指利用多个计算节点进行机器学习或者深度学习的算法和系统，旨在提高性能、保护隐私，并可扩展至更大规模的训练数据和更大的模型。 举个例子，一个由三个计算节点和一个参数服务器组成的分布式机器学习系统如下，训练数据被分为不相交的数据分片并被发送给各个计算节点，计算节点将在本地执行随机梯度下降（SGD）。计算节点将梯度或者模型参数发送至参数服务器。
【分布式机器学习】
图挖掘领域，新晋砖家 ☞ 未来可期，欢迎和静静一起学习交流吖
09-15 1060
转载 https://blog.youkuaiyun.com/liangdaojun/article/details/100011356 文章序列 分布式机器学习（一）之总体概述 分布式机器学习（二）之数据划分 分布式机器学习（三）之模型划分 分布式机器学习（四）之节点通讯 文章目录
分布式机器学习概念
sfakh的博客
09-06 1549
分布式机器学习理论概念
分布式机器学习（下）-联邦学习
古月哲亭
09-30 3544
原文链接：https://zhuanlan.zhihu.com/p/114028503 本视频来源于Shusen Wang讲解的《分布式机器学习》，总共有三讲，内容和连接如下：并行计算与机器学习（上）并行计算与机器学习（下）联邦学习：技术角度的讲解这节课的内容是联邦学习。联邦学习是一种特殊的分布式机器学习，是最近两年机器学习领域的一个大热门。联邦学习和传统分布式学习有什么区别呢？什么是Federated Averaging算法？联邦学习有哪些研究方向呢？我将从技术的角度进行解答。 这节课的主要内容：分布式机
联邦学习与分布式学习的区别
qq_43359515的博客
11-11 2731
联邦学习问题： 我们的目标是在设备生成的数据被本地存储和处理的约束下学习这个模型，而只有中间更新周期性与中央服务器进行通信。 一、联邦学习与分布式学习的区别 1.用户对自己的设备和数据有绝对的控制权，可以随时让自己的设备停止参与计算与通信； 2.worked node是不稳定的设备； 3.通信代价远大于计算代价； 4.联邦学习的数据不是独立同分布的； 5.联邦学习的节点负载不平衡。 二、联邦学习研究点 1.算法的效率； 2.保护隐私； 3.鲁棒性（拜占庭将军问题）。 ...
分布式学习
02-13
分布式学习是一种先进的计算模型，它在多个计算节点之间分配机器学习任务，以提高处理大数据集和复杂算法的效率。这种技术已经成为现代数据科学和人工智能领域不可或缺的一部分，尤其在处理大规模机器学习项目时，其...
分布式机器学习系统 工程与实战.pptx
10-01
《分布式机器学习系统、工程与实战》是一本全面深入地探讨分布式机器学习领域的书籍，主要内容包括分布式机器学习的发展历程、系统架构、工程构建以及实际应用案例。 一、分布式机器学习的发展历程 分布式机器学习...
分布式学习环境构建的反思与前瞻.pdf
08-09
分布式学习的核心特征之一是以建构主义学习理论为基础。建构主义主张知识是通过主体与环境的互动产生的，强调学习是个体和社会参与的认知过程。在分布式学习中，学习者不仅在个人层面构建意义，而且在社会环境中与...
分布式学习文档
11-07
分布式学习文档涵盖了大量的关键知识点，主要集中在分布式Java应用、分布式系统的基本概念与设计，以及大规模分布式存储系统的原理和架构实战。以下是对这些主题的详细解释： 1. **分布式Java应用**： 分布式Java...
基于Spark MLlib分布式学习算法的研究.pdf
08-10
传统的单机算法在处理大规模数据时会面临性能瓶颈，而分布式学习算法则可以有效地解决这一问题。分布式学习算法通过分布数据在不同的计算节点上进行并行处理，以提高数据处理效率和算法性能。 Apache Spark是一个...
CCS V5 的安装与使用.ppt
最新发布
08-08
CCS V5 的安装与使用
制造业C# ERP管理系统源码：从客户档案到财务管理的一站式解决方案
08-08
内容概要：本文介绍了基于C#开发的制造业通用ERP管理系统源码，涵盖多个关键业务模块，包括基础档案、样品开发、订单管理、生产管理、采购管理、材料管理、成品管理、外协管理和财务管理。每个模块都详细描述了其具体功能，如客户档案管理、订单变更记录、生产排产、采购明细、库存查询、成品出库以及各种财务事务的处理。通过该系统，企业可以实现对生产、采购、销售、财务等环节的全面信息化管理，从而提升运营效率并降低运营成本。 适合人群：从事制造业信息化建设的技术人员、项目经理、企业管理层。 使用场景及目标：适用于希望构建或优化自身ERP系统的制造型企业，旨在提供一套完整的、一站式的解决方案，帮助企业在各个业务流程上实现高效协同运作。 其他说明：文中不仅提供了详细的模块功能介绍，还强调了各模块间的数据流动和相互协作关系，为开发者和技术团队提供了宝贵的参考资料。
Python程序设计与数据科学导论期中大作业：基于观影数据集的数据分析与挖掘
08-08
资源下载链接为： https://pan.quark.cn/s/b019e98ecb66 Python程序设计与数据科学导论期中大作业：基于观影数据集的数据分析与挖掘（最新、最全版本！打开链接下载即可用！）
蓝桥杯竞赛简单介绍.md
08-08
蓝桥杯全国软件和信息技术专业人才大赛是自 2010 年起举办的全国性赛事，由工业和信息化部人才交流中心主办，在高校和行业内认可度高、知名度广。​ 其旨在推动相关领域人才培养，提升学生创新、实践和职业素养，为行业输送高素质人才，且紧跟技术趋势与产业需求，为选手提供展示、交流和竞技平台。​ 竞赛组别丰富，含软件类（如 C/C++、Java、Python 程序设计等）和电子类（如嵌入式、单片机设计与开发等），面向全国普通高校及中职院校学生，分本科组、高职高专组等，保障公平与针对性。​ 竞赛分省赛（3 - 4 月，闭卷考基础）和全国总决赛（5 - 6 月，含笔试、现场编程等，考察综合能力）两阶段。内容围绕核心知识与前沿技术，兼顾基础理论与实践技能，题目具创新性和实用性。​ 对学生而言，参与可激发学习兴趣、提升能力，竞赛成绩还能为升学、就业加分，深受师生和企业好评，在人才培养及产学研结合方面作用显著。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值