精华内容
下载资源
问答
  • 训练深层次网络中的问题和一些解决办法训练深层次的网络梯度消失/爆炸问题---[参考](https://blog.csdn.net/zhangbaoanhadoop/article/details/81807548)非饱和激活函数(ReLU函数 or leaky ReLU)[批量标准化]...

    训练深层次的网络

    当需要解决非常复杂的问题时,有可能需要训练数数十层或更多的神经网路,每层也许包含数百个神经元,通过数十万个连接。这时训练就面临着如下的问题:

    • 梯度消失或者梯度爆炸,并且低层难以训练
    • 训练缓慢
    • 具有数百万参数的模型将会有严重的过拟合训练集的风险
      因此,我们将讨论这些问题,并提出解决技巧。

    梯度消失/爆炸问题—参考

    反向传播算法的工作原理是从输出层到输入层,传播误差的梯度。当算法计算了网络中的每个参数的损失函数的梯度,就会在这些梯度下降步骤中来更新每个参数。

    但是,随着网络的层次加深或者激活函数的选择不当,就会出现梯度消失/爆炸问题。

    非饱和激活函数(ReLU函数 or leaky ReLU)

    • ReLu 死区
    当小于0的这部分值,梯度会迅速降为0而不在影响网络训练。 这会造成部分神经元从来不被激活,也称作“死区”
    
    因此引入了,Leaky ReLU.
    
    • Leaky ReLU

    将小于0部分的梯度提高到

    \alpha 
    

    一般取较小的正数,如0.01 或 0.001

    ELU 激活函数的主要缺点是计算速度慢于 ReLU 及其变体(由于使用指数函数),但是在训
    练过程中,这是通过更快的收敛速度来补偿的。 然而,在测试时间,ELU 网络将比 ReLU 网
    络慢。

    • 如何选择激活函数

    一般 ELU > leaky ReLU(及其变体) > ReLU > tanh > sigmoid。

    如果您关心运行时性能,那么
    您可能喜欢 leaky ReLU超过ELU。

    如果你不想调整另一个超参数,你可以使用前面提到的默
    认的 α 值(leaky ReLU 为 0.01,ELU 为 1)。

    如果您有充足的时间和计算能力,您可以使
    用交叉验证来评估其他激活函数,特别是如果您的神经网络过拟合,则为RReLU;

    如果您拥有庞大的训练数据集,则为 PReLU

    批量标准化(Batch Normalization,BN)

    • 对输入层进行中心(Zero-Centering) 和 标准化

      中心化:使数据均值为0,标准差为1;

      标准化:是数据输出映射为[0,1]

    • 中间层的输入(激活函数前)使用两个新参数对结果进行尺度变换和偏移
      一个用于尺度变换
      一个用于偏移

    • Batch Normalization algorithm

    \mu _B = \frac{1}{m_B} \sum_{i=1}^{m_B} x^i ;
    
    {\sigma}_B^2 = \frac{1}{m_B} \sum_{i=1}^{m_B}(x^i - \mu _B)^2 ;
    
    \hat{x}_i = \frac{x^i - \mu_B}{\sqrt[2]{\sigma_B^2} + \epsilon}
    
    z^i = \gamma \hat{x}^i + \beta
    
    
    \mu_B
    

    是整个小批量B的经验均值

    {\sigma}_B
    

    是经验性的标准差,也是来评估整个小批量的

    m_B
    

    是小批量中的实例数量

    \hat{x}_i
    

    是以中心化和标准化的输入

    \gamma
    

    是层的缩放参数

    \beta
    

    是层的移动参数(偏移量)

    \epsilon
    

    通常选择一个很小的数字,避免被0整除(10^ -3),该项被称为平滑项(Laplace Smoothing)

    z^i
    

    是BN操作的输出,是输入缩放和移位后的状态

    作者证明,这项技术大大改善了他们试验的所有深度神经网络。梯度消失问题大大减少了,
    他们可以使用饱和激活函数,如 tanh 甚至 sigmoid 激活函数。网络对权重初始化也不那么敏
    感。他们能够使用更大的学习率,显著加快了学习过程。具体地,他们指出,“应用于最先进
    的图像分类模型,批标准化用少了 14 倍的训练步骤实现了相同的精度,以显著的优势击败了
    原始模型。批量标
    准化也像一个正则化项一样,减少了对其他正则化技术的需求(如
    dropout).

    然而,批量标准化的确会增加模型的复杂性(尽管它不需要对输入数据进行标准化,因为第
    一个隐藏层会负责这一点,只要它是批量标准化的)。 此外,还存在运行时间的损失:由
    于每层所需的额外计算,神经网络的预测速度较慢。 所以,如果你需要预测闪电般快速,你
    可以尝试普通ELU + He初始化执行之前如何执行批量标准化。

    Tensorflow 的实现

    import tensorflow as tf
    
    tf.layers.batch_normalization()
    
    
    展开全文
  • 我们根据每个人的layer把相同layer的人分配到同一个层次中。 然后记录走到每个层次的最小值。如果这个最小值被更新了, 那么我们就更新与这个层次相连的层次上的点。 其他的就是最普通的spfa求最短路了。 不过要...


    我们根据每个人的layer把相同layer的人分配到同一个层次中。

    然后记录走到每个层次的最小值。如果这个最小值被更新了, 那么我们就更新与这个层次相连的层次上的点。

    其他的就是最普通的spfa求最短路了。

    不过要用优先队列优化一下。

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #include<iostream>
    #include<algorithm>
    #include<vector>
    #include<queue>
    #include<map>
    using namespace std;
    #define maxn 110000
    #define INF 99999999
    struct list
    {
        int next;
        int u,v,w;
    } edge[maxn*2];
    vector<int>vec[maxn];
    struct listt
    {
        int u;
        int w;
        friend bool operator <(const listt &a,const listt &b)
        {
            return a.w>b.w;
        }
    } p,q;
    priority_queue<struct listt>que;
    int head[maxn];
    int nums;
    map<int,int>mp;
    void init()
    {
        for(int i=0; i<maxn; i++)vec[i].clear();
        memset(head,-1,sizeof(head));
        nums=1;
        while(!que.empty())que.pop();
        mp.clear();
    }
    void add(int u,int v,int w)
    {
        edge[nums].u=u;
        edge[nums].v=v;
        edge[nums].w=w;
        edge[nums].next=head[u];
        head[u]=nums++;
    }
    int dis[maxn];
    int minn[maxn];
    int belong[maxn];
    int ans[maxn];
    int spfa(int st,int ed,int k)
    {
        for(int i=0; i<=ed; i++)dis[i]=INF;
        for(int i=0; i<=maxn; i++)minn[i]=INF;
        p.u=st;
        p.w=0;
        que.push(p);
        dis[st]=0;
        while(!que.empty())
        {
            q=que.top();
            que.pop();
            if(q.u==ed)
            {
                return q.w;
            }
            int x=belong[q.u];
            if(q.w<minn[x])
            {
                minn[x]=q.w;
                p.w=minn[x]+k;
                if(ans[x-1]+1==ans[x])
                {
                    for(int i=0; i<vec[x-1].size(); i++)
                    {
                        p.u=vec[x-1][i];
                        if(dis[p.u]>p.w)
                        {
                            dis[p.u]=p.w;
                            que.push(p);
                        }
    
                    }
                }
                if(ans[x]+1==ans[x+1])
                {
                    for(int i=0; i<vec[x+1].size(); i++)
                    {
                        p.u=vec[x+1][i];
                        if(dis[p.u]>p.w)
                        {
                            dis[p.u]=p.w;
                            que.push(p);
                        }
                    }
                }
            }
            for(int i=head[q.u]; i!=-1; i=edge[i].next)
            {
                int v=edge[i].v;
                int w=edge[i].w;
                if(dis[v]>dis[q.u]+w)
                {
                    dis[v]=dis[q.u]+w;
                    p.u=v;
                    p.w=dis[v];
                    que.push(p);
                }
            }
        }
        return -1;
    }
    vector<int>all;
    int main()
    {
        int cas=0;
        int T,m,n,k,u,v,w;
        scanf("%d",&T);
        while(T--)
        {
            cas++;
            init();
            scanf("%d%d%d",&n,&m,&k);
            all.clear();
            for(int i=1; i<=n; i++)
            {
                scanf("%d",&belong[i]);
                //vec[belong[i]].push_back(i);
                all.push_back(belong[i]);
            }
            //-----离散化
            sort(all.begin(),all.end());
            int st=1;
            mp[all[0]]=1;
            ans[1]=all[0];
            for(int i=1; i<all.size(); i++)
            {
                if(all[i]!=all[i-1])
                {
                    mp[all[i]]=++st;
                    ans[st]=all[i];
    
                }
            }
            //-------------------
            for(int i=1; i<=n; i++)
            {
                int x=mp[belong[i]];
                vec[x].push_back(i);
                belong[i]=x;
            }
            for(int i=1; i<=m; i++)
            {
                scanf("%d%d%d",&u,&v,&w);
                add(u,v,w);
                add(v,u,w);
            }
            printf("Case #%d: %d\n",cas,spfa(1,n,k));
        }
        return 0;
    }
    


    展开全文
  • 出现梯度消失和爆炸的原因基本上归为两点:一,网络层次太深,由于很多网络的更新时的链式原理,使得更新信息往往指数级变化;二,采用了不合适的激活函数,比如sigmoid,梯度爆炸一般出现在深层网络和权值初始化值...

    关于梯度消失和爆炸,其前提是采用梯度下降办法去更新网络参数,使得代价函数最小化。出现梯度消失和爆炸的原因基本上归为两点:一,网络层次太深,由于很多网络的更新时的链式原理,使得更新信息往往指数级变化;二,采用了不合适的激活函数,比如sigmoid,梯度爆炸一般出现在深层网络和权值初始化值太大的情况下。

    1.深层网络角度

    比较简单的深层网络如下:

    这里写图片描述


    图中是一个四层的全连接网络,假设每一层网络激活后的输出为f_{i}\left ( x \right ),其中i为第i层, x代表第i层的输入,f是激活函数,那么,得出f_{i+1}=f\left ( f_{i}*\omega _{i+1}+b_{i+1} \right )
    例如BP算法基于梯度下降策略,以目标的负梯度方向对参数进行调整,参数的更新为w←w+Δw,给定学习率α,得出\Delta \omega =-\alpha \frac{\partial Loss}{\partial \omega }​。如果要更新第二隐藏层的权值信息,根据链式求导法则,更新梯度信息:
    \Delta \omega _{2}=\frac{\partial Loss}{\partial \omega _{2}}=\frac{\partial Loss}{\partial f_{4}}\frac{\partial f_{4}}{\partial f_{3}}\frac{\partial f{_{3}}}{\partial f{_{2}}}\frac{\partial f_{2}}{\partial \omega _{2}},很容易看出来\frac{\partial f_{2}}{\partial \omega _{2}}=\frac{\partial f}{\partial (f_{1}*\omega _{2}))}f_{1}​,即第二隐藏层的输入。
    所以说,\frac{\partial f_{3}}{\partial f_{4}}​​就是对激活函数进行求导,如果此部分大于1,那么层数增多的时候,最终的求出的梯度更新将以指数形式增加,即发生梯度爆炸,如果此部分小于1,那么随着层数增多,求出的梯度更新信息将会以指数形式衰减,即发生了梯度消失。

    2.激活函数角度

    其实也注意到了,上文中提到计算权值更新信息的时候需要计算前层偏导信息,因此如果激活函数选择不合适,比如使用sigmoid,梯度消失就会很明显了,原因看下图,左图是sigmoid的损失函数图,右边是其导数的图像,如果使用sigmoid作为损失函数,其梯度是不可能超过0.25的,这样经过链式求导之后,很容易发生梯度消失。


    sigmoid函数sigmoid函数导数

    梯度消失、爆炸的解决方案

    1.梯度剪切、正则

    梯度剪切这个方案主要是针对梯度爆炸提出的,其思想是设置一个梯度剪切阈值,然后更新梯度的时候,如果梯度超过这个阈值,那么就将其强制限制在这个范围之内。这可以防止梯度爆炸。

    另外一种解决梯度爆炸的手段是采用权重正则化(weithts regularization)。

    2.换用relu、leakrelu、elu等激活函数

    3.LSTM

    LSTM全称是长短期记忆网络(long-short term memory networks),是不那么容易发生梯度消失的,主要原因在于LSTM内部复杂的“门”(gates),如下图,LSTM通过它内部的“门”可以接下来更新的时候“记住”前几次训练的”残留记忆“,因此,经常用于生成文本中。

     

    这里写图片描述

    展开全文
  • Socket通讯:  网络上的两个程序通过一个双向的通讯连接实现数据的交互,这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面,一个Socket...

    [本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020]

    Socket通讯:

      网络上的两个程序通过一个双向的通讯连接实现数据的交互,这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面,一个Socket由一个IP地址和一个端口号唯一确定。

      在传统的UNIX环境下可以操作TCP/IP协议的接口不止Socket一个,Socket所支持的协议种类不光是TCP/IP一种,因此两者之间没有必然的联系。在java环境下,Socket编主要是基于TCP/IP协议的网络编程。


    Socket通讯的一般过程:

      使用Socket进行Client/Server程序设计的一般连接过程是这样的:Server端Listen(监听)某个端口是否有连接请求,Client端向Server端发回Connect(连接请求), Server端向Client端发回Accept(接受)消息。一个连接就建立起来了。Server端和Client端都可以通过Send,Write等方法与对方通信。

      对于一个功能齐全的Socket,都要包含以下基本结构,其工作过程包含以下四个基本的步骤:

      (1). 创建Socket;

      (2). 打开连接到Socket的输入/出流。

      (3). 按照一定的协议对Socket进行读/写操作。

      (4). 关闭Socket。


    创建Socket:

      java在java.net中提供了两个类Socket和ServerSocket,分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类,使用很方便,构造方法如下:

    Socket();
    
    Socket(Proxy proxy);
    
    Socket(InetAddress address,int port);
    
    Socket(InetAddress address,int port,boolean stream);
    
    Socket(String host,int port);
    
    Socket(String host,int port,boolean stream);
    
    Socket(SocketInmpl impl);
    
    Socket(String host,int port,InetAddress localAddr,int localPort);
    
    Socket(InetAddress address,int port,InetAddress localAddr,int localPort);
    
    ServerSocket();
    
    ServerSocket(int port);
    
    ServerSocket(int port,int backup);
    
    ServerSocket(int port,int backup,InetAddress bindAddr);

      其中,address,host和port分别是双向连接中另一方的ip地址,主机名和端口号,stream指明socket是流socket还是数据报socket,localPort表示本地主机的端口号,localAddr和bindAddr是本地机器的的地址,impl是socket的父类,既可以用来创建serverSocket又可以用来创建Socket。如:

    Socket client  = new Socket("127.0.0.1",2000);

    ServerSocket server = new ServerSocket(2000);

      注意,在选择端口时,需要小心,每个端口提供的一种特定的服务,只有给出正确的端口,才能获得相应的服务,0~1023为系统保留,如http服务端口号80,telent服务端口号21,所以我们在选择端口时,最好选择一个大于1023的数,以防止冲突。


    用Socket实现客户端与服务端交互:

      单线程实现:

       如果,客户端与服务端均采用单线程实现通信,则每次双方只能发送一条信息,即按:client发-server收-server发-client收.......这种模式进行通讯,可以观察下列单线程实现代码输出结果:


    客户端代码SocketTalkClient.java:

    package com.jesson.mianshi.network;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    public class SocketTalkClient {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		SocketTalkClient client = new SocketTalkClient();
    		// 测试单线程实现的客户端与服务端交互
    		System.out.println("client: 单线程........");
    		client.singleThreadTalkClient();
    	}
    
    	/**
    	 * 单线程实现的客户端与服务端通信
    	 */
    	public void singleThreadTalkClient() {
    		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")) {
    				os.println(readline);
    				// 将从系统标准输入读入的字符串输出到Server
    				os.flush();
    				// 刷新输出流,使Server马上收到该字符串
    				System.out.println("Client: " + readline);
    				try {
    					System.out.println("Server: " + is.readLine());
    				} catch (IOException e) {
    					readline = sin.readLine();
    					continue;
    				}
    				readline = sin.readLine(); // 从系统标准输入读入一字符串
    			} // 继续循环
    
    			os.close(); // 关闭Socket输出流
    			is.close(); // 关闭Socket输入流
    			socket.close(); // 关闭Socket
    		} catch (Exception e) {
    			System.out.println("error");
    		}
    	}
    }

    服务端代码SocketTalkServer.java:

    package com.jesson.mianshi.network;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTalkServer {
    
    	public static void main(String[] args) {
    		SocketTalkServer server = new SocketTalkServer();
    		// 测试单线程实现的客户端与服务端交互
    		System.out.println("server: 单线程........");
    		server.singleThreadTalkServer();
    	}
    
    	/**
    	 * 单线程实现的客户端与服务端通信
    	 */
    	public void singleThreadTalkServer() {
    		ServerSocket server = null;
    		try {
    			server = new ServerSocket(4700);
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not listen to:" + e);
    		}
    		Socket socket = null;
    		try {
    			socket = server.accept();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not accept socket from client:" + e);
    		}
    		String line;
    		try {
    
    			BufferedReader is = new BufferedReader(new InputStreamReader(
    					socket.getInputStream()));
    			PrintStream os = new PrintStream(socket.getOutputStream());
    			BufferedReader sin = new BufferedReader(new InputStreamReader(
    					System.in));
    			System.out.println("client: " + is.readLine());
    
    			line = sin.readLine();
    			while (!line.equals("bye")) {
    				os.println(line);
    				os.flush();
    				System.out.println("Server: " + line);
    				System.out.println("Client: " + is.readLine());
    				line = sin.readLine();
    			}
    			os.close();
    			is.close();
    			socket.close();
    			server.close();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("error: " + e);
    		}
    	}
    }
    
      程序执行输出结果:

    客户端输出:

    client: 单线程........
    hello server
    Client: hello server
    Server: hello cient
    我每次只能发送一条消息
    Client: 我每次只能发送一条消息
    Server: 我也是

    服务端输出:

    <span style="font-size:14px;">server: 单线程........
    client: hello server
    hello cient
    Server: hello cient
    Client: 我每次只能发送一条消息
    我也是
    Server: 我也是</span>

      多线程实现:

      可以看出,用单线程实现,客户端每次只能发送一条消息,要实现双方都可以发送任意条消息,这就需要用到多个线程了,这里用了两个线程来实现监听和写。代码如下:

    客户端代码(SocketTalkClient.java):

    package com.jesson.mianshi.network;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTalkServer {
    
    	public static void main(String[] args) {
    		SocketTalkServer server = new SocketTalkServer();
    
    		// 测试多线程实现的客户端与服务端交互
    		System.out.println("server: 多线程........");
    		server.MultiThreadTalkServer();
    	}
    
    	/**
    	 * 多线程实现的客户端与服务端交互
    	 */
    	private void MultiThreadTalkServer() {
    		ServerSocket server = null;
    		try {
    			server = new ServerSocket(4701);
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not listen to:" + e);
    		}
    		Socket socket = null;
    		try {
    			socket = server.accept();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not accept socket from client:" + e);
    		}
    		String line;
    		try {
    
    			BufferedReader is = new BufferedReader(new InputStreamReader(
    					socket.getInputStream()));
    			PrintWriter os = new PrintWriter(socket.getOutputStream());
    			BufferedReader sin = new BufferedReader(new InputStreamReader(
    					System.in));
    
    			new ServerLinstenThread(is).start();
    			new ServerWriteThread(sin, os).start();
    
    			/*
    			 * os.close(); is.close(); socket.close(); server.close();
    			 */
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("error: " + e);
    		}
    	}
    
    	/**
    	 * 服务端听线程
    	 * 
    	 * @author jesson
    	 * 
    	 */
    	class ServerLinstenThread extends Thread {
    		private BufferedReader linsten;
    
    		public ServerLinstenThread(BufferedReader linsten) {
    			// TODO Auto-generated constructor stub
    			this.linsten = linsten;
    		}
    
    		public void run() {
    			// TODO Auto-generated method stub
    			String clientInfo;
    			try {
    
    				while (true) {
    					clientInfo = linsten.readLine();
    					System.out.println("Client: " + clientInfo);
    					if (clientInfo.equals("bye")) {
    						System.out.println("Client下线,程序退出");
    						System.exit(0);
    					}
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    
    	/**
    	 * 服务端端写线程
    	 * 
    	 * @author jesson
    	 * 
    	 */
    	class ServerWriteThread extends Thread {
    
    		private BufferedReader writer;
    		private PrintWriter printWriter;
    
    		public ServerWriteThread(BufferedReader writer, PrintWriter printWriter) {
    			this.writer = writer;
    			this.printWriter = printWriter;
    		}
    
    		public void run() {
    			// TODO Auto-generated method stub
    			String serverInfo;
    			try {
    				while (true) {
    					serverInfo = writer.readLine();
    					printWriter.println(serverInfo);
    					printWriter.flush();
    					System.out.println("Server: " + serverInfo);
    					if (serverInfo.equals("bye")) {
    						System.out.println("Server自己下线,程序退出");
    						System.exit(0);
    					}
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    
    		}
    
    	}
    }
    
    服务端代码(SocketTalkServer.java):

    package com.jesson.mianshi.network;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTalkServer {
    
    	public static void main(String[] args) {
    		SocketTalkServer server = new SocketTalkServer();
    
    		// 测试多线程实现的客户端与服务端交互
    		System.out.println("server: 多线程........");
    		server.MultiThreadTalkServer();
    	}
    
    	/**
    	 * 多线程实现的客户端与服务端交互
    	 */
    	private void MultiThreadTalkServer() {
    		ServerSocket server = null;
    		try {
    			server = new ServerSocket(4701);
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not listen to:" + e);
    		}
    		Socket socket = null;
    		try {
    			socket = server.accept();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("can not accept socket from client:" + e);
    		}
    		String line;
    		try {
    
    			BufferedReader is = new BufferedReader(new InputStreamReader(
    					socket.getInputStream()));
    			PrintWriter os = new PrintWriter(socket.getOutputStream());
    			BufferedReader sin = new BufferedReader(new InputStreamReader(
    					System.in));
    
    			new ServerLinstenThread(is).start();
    			new ServerWriteThread(sin, os).start();
    
    			/*
    			 * os.close(); is.close(); socket.close(); server.close();
    			 */
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			System.out.println("error: " + e);
    		}
    	}
    
    	/**
    	 * 服务端听线程
    	 * 
    	 * @author jesson
    	 * 
    	 */
    	class ServerLinstenThread extends Thread {
    		private BufferedReader linsten;
    
    		public ServerLinstenThread(BufferedReader linsten) {
    			// TODO Auto-generated constructor stub
    			this.linsten = linsten;
    		}
    
    		public void run() {
    			// TODO Auto-generated method stub
    			String clientInfo;
    			try {
    
    				while (true) {
    					clientInfo = linsten.readLine();
    					System.out.println("Client: " + clientInfo);
    					if (clientInfo.equals("bye")) {
    						System.out.println("Client下线,程序退出");
    						System.exit(0);
    					}
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    
    	/**
    	 * 服务端端写线程
    	 * 
    	 * @author jesson
    	 * 
    	 */
    	class ServerWriteThread extends Thread {
    
    		private BufferedReader writer;
    		private PrintWriter printWriter;
    
    		public ServerWriteThread(BufferedReader writer, PrintWriter printWriter) {
    			this.writer = writer;
    			this.printWriter = printWriter;
    		}
    
    		public void run() {
    			// TODO Auto-generated method stub
    			String serverInfo;
    			try {
    				while (true) {
    					serverInfo = writer.readLine();
    					printWriter.println(serverInfo);
    					printWriter.flush();
    					System.out.println("Server: " + serverInfo);
    					if (serverInfo.equals("bye")) {
    						System.out.println("Server自己下线,程序退出");
    						System.exit(0);
    					}
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    
    		}
    	}
    }

      执行上述代码,运行结果:

    客户端输出:

    client: 多线程........
    你好,server
    Client: 你好,server
    Server: 你好,client
    Server: server发送多条信息:
    Server: 1. abcd
    Server:  2. 1234
    Server:  3. ABC
    client发送多条消息:
    Client: client发送多条消息:
    1. xxxxx
    Client: 1. xxxxx
    2.yyyy
    Client: 2.yyyy
    3.zzzz
    Client: 3.zzzz
    bye
    Client: bye
    Client自己下线,程序退出

    服务端输出:

    server: 多线程........
    Client: 你好,server
    你好,client
    Server: 你好,client
    server发送多条信息:
    Server: server发送多条信息:
    1. abcd
    Server: 1. abcd
     2. 1234
    Server:  2. 1234
     3. ABC
    Server:  3. ABC
    Client: client发送多条消息:
    Client: 1. xxxxx
    Client: 2.yyyy
    Client: 3.zzzz
    Client: bye
    Client下线,程序退出
      


    展开全文
  • 网络层次结构

    2019-03-22 14:47:04
    网络层次结构第一层 链路层网卡以及网卡驱动,只负责数据的传输,无连接的,也不做差错检验,只负责传送到指定的网卡地址。第二层 网络层 ip协议属于网络层,负责数据传送到指定的ip地址,但不做差错检验,arp协议也...
  • 网络层次划分

    千次阅读 2019-03-14 12:47:54
    1. 网络层次划分  为了使不同计算机厂家生产的计算机能够相互通信,以便在更大的范围内建立计算机网络,国际标准化组织(ISO)在1978年提出了“开放系统互联参考模型”,即著名的OSI/RM模型(Open System ...
  • IOS网络层次

    2016-06-07 14:59:42
    一、iOS网络层次结构 基于iOS提供API实现上传文件和断点续传的思路 常用iOS第三方网路框架简介 AFNetworking(AFN) ASIHTTPRequest(ASI) 另外一个常用框架 SSZipArchive 二、iOS网络编程层次结构 Cocoa层...
  • 层次化网络设计(三层网络结构)

    万次阅读 2019-05-14 21:51:45
    三层网络架构是采用层次化架构的三层网络。 三层网络架构采用层次化模型设计,即将复杂的网络设计分成几个层次,每个层次着重于某些特定的功能,这样就能够使一个复杂的大问题变成许多简单的小问题。三层网络架构...
  • 网络层次分析

    2017-05-31 22:15:22
    网络层的任务就是选择合适的间路由和交换结点, 确保数据及时传送。网络层将数据链路层提供的帧组成数据包,包中封装有网络层包头,其中含有逻辑地址信息- -源站点和目的站点地址的网络地址。如 果你在谈论一个IP...
  • 层次化网络设计

    千次阅读 2014-10-23 09:59:42
    层次化网络设计在互联网组件的通信中引入了三个关键层的概念,这三个层分别是:核心层(Core Layer)、汇聚层(Distribution Layer)和接入层(Access Layer) 1.核心层为网络提供骨干组件或高速交换组件,高效速度传输是...
  • 层次、网状、关系模型

    万次阅读 多人点赞 2017-11-18 17:12:44
    层次、网状、关系模型都是逻辑上的,它们都是以一定的方式存储在数据库系统中,这是数据库管理系统的功能,是数据库管系统中的物理存储模型。 格式化模型层次模型和网状模型统称为格式化模型。格式化模型中数据结构...
  • 网络中的层次架构

    千次阅读 2019-03-12 14:44:05
    ISO七层网络架构 七层 物理层,数据链路层,网络层,运输层,...主要包括电缆、物理端口和附属设备,如双绞线、同轴电缆、接线设备(如网卡等)、RJ-45接口、串口和并口等在网络中都是工作在这个层次的。 物...
  • 网络层次的划分

    万次阅读 2017-12-24 20:09:05
    为了使不同计算机厂家生产的计算机能够相互通信,国际标准化组织(ISO)在1978年提出了“开放系统互联参考模型”,即著名的OSI/RM模型(Open System Interconnection/Reference Model)。它将计算机网络体系结构的...
  • 网络层次协议的由来

    2014-05-27 11:04:42
    我们知道,互联网我们是分了不少层次来进行管理和学习的。那么,是如何进行分层,又如何进行协议的划分的呢?网络层次协议的使用是我们接下来想要为大家讲解的内容。那么相关的一些知识还请大家从文章中来详细了解...
  • ospf网络层次化设计

    2010-11-05 21:26:00
    link-state路由在设计时要求需要一个层次化的网络结构ospf网络有以下2个级别的层次骨干区域backbone or area 0非骨干区域 nonbackbone areas
  • 从计算机网络协议层次讲网络

    千次阅读 2018-09-01 20:38:58
    计算机网络协议层次
  • 协议与网络层次

    2016-04-23 21:30:28
  • iOS网络编程层次模型

    千次阅读 2015-03-25 19:48:54
    iOS网络编程层次结构也分为三层:   Cocoa层:NSURL,Bonjour,Game Kit,WebKitCore Foundation层:基于 C 的 CFNetwork 和 CFNetServicesOS层:基于 C 的 BSD socket  Cocoa层:是最上层的基于 ...
  • 网络层次与主要设备对应关系 互联设备 工作层次 主要功能 中继器 物理层 对接受信号进行再次和发送,只起到扩展传输距离用,对高层协议是透明的,但使用个数有限(以太网是4个) 网桥 数据链...
  • 网络服务器预防dos攻击的层次

    千次阅读 2010-10-24 14:17:00
    web服务器在处理请求的时候会涉及三个层次,第一个层析是tcp连接的层次,第二个层次是http请求的层次,第三个层次是业务处理的层次,每个层次都可能存在dos攻击,所要作的预防措施就是每个更低的层次未决之前不为其...
  • 计算机网络-网络层次结构

    千次阅读 2014-08-15 08:47:53
    计算机网络-网络层次结构 OSI七层模型和TCP/IP协议
  • 网络协议层次及其物理对应

    千次阅读 2010-12-02 10:10:00
    网络协议层次及其物理对应
  • 网络协议层次

    2013-12-09 11:17:44
  • 网络规划之层次划分

    2010-02-10 10:18:51
    网络的层次划分1.核心层交换数据包,实现高速的数据流量运转,核心层的设备不但需要容量大,转发快,而且需要具备高稳定性,但通常对业务的需求高。2.汇聚层隔离拓扑结构变化,控制路由表的大小及控制流量,端口的...
  • 网状,层次数据库的优缺点!

    千次阅读 2018-05-01 19:10:05
    (1)模型简单,对具有一对多层次关系的部门描述非常自然,直观,容易理解,这是层次数据库的突出优点(2)用层次模型的应用系统性能好,特别是对于那些实体间联系固定的且预先定义好的应用,采用层次模型来实现,其...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,109
精华内容 7,243
关键字:

层次网