import android.support.v7.app.ActionBarActivity; import android.annotation.SuppressLint; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.view.Menu; import android.view.MenuItem; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.TextView; import android.widget.Toast; public class YuntuActivity extends ActionBarActivity implements OnClickListener { private TextView adSpeed; private TextView reSpeed; private TextView reTxt; private Button btnHeadCar; private Button btnAgree; private Button btnApply; private Button btnStart; private Button btnExit; //自定义变量 private String remoteIP = null; private int rePort = 0; private int loPort = 0; private <em>UDP</em>Thread reTxtThread = null; private <em>UDP</em>Thread adSpeedThread = null; private <em>UDP</em>Thread reSpeedThread = null; private String sendStr = null;//发送的字符串 private String receStr = null; Handler mhander = new Handler() { public void handleMessage(Message msg) { Bundle bundle =new Bundle(); bundle = msg.getData(); receStr = bundle.getString("info"); reTxt.setText(receStr); } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_yuntu); //初始化UI initUI(); //初始化 init(); reTxtThread = new <em>UDP</em>Thread(mhander); } private void init() { remoteIP = "172.22.130.124"; rePort = 8801; loPort = 8805; } //初始化UI private void initUI() { adSpeed =(TextView)findViewById(R.id.AdSpeed); reSpeed =(TextView)findViewById(R.id.ReSpeed); reTxt =(TextView)findViewById(R.id.reTxt); btnHeadCar =(Button)findViewById(R.id.button1); btnAgree =(Button)findViewById(R.id.button2); btnApply =(Button)findViewById(R.id.button3); btnStart =(Button)findViewById(R.id.button4); btnExit =(Button)findViewById(R.id.button5); } @Override public void onClick(View v) { switch (v.getId()) { //点击 同意入队 按钮 case R.id.button1: sendStr = "you can join in flownteam."; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击 申请入队按钮 case R.id.button2: sendStr = "Can I join in?"; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击申请离队按钮 case R.id.button3: sendStr = "Can I exit?"; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击开始监听按钮 case R.id.button4: reTxtThread.setReomteIP(remoteIP); reTxtThread.setRePort(rePort); reTxtThread.setLoPort(loPort); boolean connResult = reTxtThread.connectSocket(); if(connResult) { Toast.makeText(getApplicationContext(), "链接建立完毕！", Toast.LENGTH_SHORT).show(); } break; //点击关闭监听按钮 case R.id.button5: reTxtThread.disConnectSocket(); Toast.makeText(getApplicationContext(), "链接已经关闭!", Toast.LENGTH_SHORT).show(); break; default: break; } } } 子线程： import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; import java.text.SimpleDateFormat; import java.util.Date; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.widget.TextView; public class <em>UDP</em>Thread implements Runnable { // 定义变量 private TextView rTextView = null; private String reomteIP = null; private int rePort = 0; private int loPort = 0; private Thread rThread = null; private static String CHARECTER = "UTF-8"; private SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss"); // 接收 private byte[] rBuffer = new byte[1024]; private DatagramSocket rSocket = null; private DatagramPacket rPacket = null; private String rStr = null; // 发送 private DatagramSocket sSocket = null; private DatagramPacket sPacket = null; private byte[] sBuffer = new byte[1024]; public Handler mhandler; public <em>UDP</em>Thread(Handler handler) { mhandler = handler; } @Override public void run() { // 开始接收<em>数据</em> Looper.prepare(); if (Thread.currentThread() == rThread) { System.out.println("------jieshouqian"); rStr = <em>receive</em>Data(); System.out.println("------jieshouhou"); Message toMain = mhandler.obtainMessage(); Bundle bundle = new Bundle(); bundle.putString("info", rStr); toMain.setData(bundle); mhandler.sendMessage(toMain); } ; try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // 开始接收<em>数据</em> private String <em>receive</em>Data() { try { ByteArrayInputStream bais = new ByteArrayInputStream(rBuffer); DataInputStream dis = new DataInputStream(bais); if (rSocket == null) { rSocket = new DatagramSocket(8805); } if (rPacket == null) { rPacket = new DatagramPacket(rBuffer, rBuffer.length); } System.out.println("----rece"); rSocket.<em>receive</em>(rPacket); System.out.println("------receHou"); rStr = dis.readUTF().trim(); System.out.println("------jieBeg"); rStr = String.format("[%s:%d//%s]%s", rPacket.getAddress() .getHostAddress(), rPacket.getPort(), sdf .format(new Date()), rStr); return rStr; } catch (Exception e) { e.printStackTrace(); System.out.println("-----------------recvdata error:" + e.getMessage()); } return null; } // 建立连接 public boolean connectSocket() { boolean result = false; // 开启一个新的线程 startThread(); System.out.print("监听线程开启"); result = true; return result; } // 关闭连接 public void disConnectSocket() { if (rSocket != null) { rSocket.close(); rSocket = null; } if (rPacket != null) { rPacket = null; } // 关闭线程 stopThread(); } // 关闭线程 private void stopThread() { if (rThread != null) { rThread.stop(); rThread = null; } } // 开启新的线程 private void startThread() { if (rThread == null) { rThread = new Thread(this); rThread.start(); } } // 开始发送<em>数据</em> public void sendData(String sendStr) { try { // 包装<em>数据</em> ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); dos.writeUTF(sendStr); sBuffer = baos.toByteArray(); if (sSocket == null) { sSocket = new DatagramSocket(); } if (sPacket == null) { sPacket = new DatagramPacket(sBuffer, sBuffer.length, InetAddress.getByName(reomteIP), rePort); } sSocket.send(sPacket); sSocket.close(); sSocket = null; sPacket = null; } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); sSocket.close(); sSocket = null; sPacket = null; System.out.println("senddata error:" + e.getMessage()); } } public void setReomteIP(String reomteIP) { this.reomteIP = reomteIP; } public void setRePort(int rePort) { this.rePort = rePort; } public void setLoPort(int loPort) { this.loPort = loPort; } }
TCP和<em>UDP</em>的区别： TCP（Transimission Control Protocol）即 传输控制协议：是面向连接的协议， 强调稳定可靠的连接，建立连接“三次握手”，断开连接需要“四次分手”，现常用于网络间视频与语音通话，及相应的网络间可靠的信息流通。 <em>UDP</em>（User Datagram Protocol）即 用户<em>数据</em>报协议：是面向报文的协议，两端无需建立连接即可传输<em>数据</em>，速度和效率都
while(true){ socket.<em>receive</em>(pacakge); } socket和pacakge是定义的DatagramSocket和DatagramPacaket,接收成功之后socket又在监听接收了，怎么才能暂时暂停一下这个阻塞，在另一个线程中使用这个socket发送一个<em>数据</em>包，然后再让这个socket继续监听接收？
1. 查看udp丢包，cat /proc/net/snmp | grep Udp（比netstat –su效果好） 2. 查看网卡丢包(ifconfig 或者ethtool –S eth1) 3. Netstat –alupt 查看队列里现存的包数，如果过多说明有问题。 4. 查看socket队列长度，cat /proc/sys/net/core/rmem_default (wmem_def
<em>UDP</em>打洞的基本原理是因为内网的计算机发送<em>UDP</em><em>数据</em>时，外网接收的端口和IP都是不同的，那么，面向连接的TCP可以使用类似的技术吗？ 比如内网两台计算机，A，B都向服务器发送<em>UDP</em><em>数据</em>，那么服务器收到
收包率低/丢包率高的原因分析 （1） 缓存太小，不能及时接收<em>数据</em>。 连续多个<em>UDP</em>包超过了<em>UDP</em>接收缓冲区大小 ，比如： 如：<em>UDP</em>包过大 如：<em>UDP</em>发包速率过快，突发大<em>数据</em>流量超过了缓冲区上限 （2）recvfrom()接收到<em>数据</em>之后处理速度太慢 如果<em>数据</em>接收和处理是连续进行的，那么可能由于<em>数据</em>处理过慢，两次recvfrom调用的时间间隔里发过来的包丢失 对应的解决方法 UD...
发送1000次。 有发送出去200多的，300多的，还有400多的。 收到的<em>数据</em>一般会少收到100到200条。 测试了10次。<em>数据</em>如下。 实际发送 / 实际接收 233 / 156 523 / 445
最近正在做穿墙技术，集各种资料，这篇算是介绍得最全面最清楚的，分享给各位朋友。
记录udp和tcp打洞过程中的重要技术点。
各位大大，看了网上好多的关于<em>UDP</em>打洞原理一说，我说下我的理解看对不对。 clientA clientB serverC 目的：A想跟B通信 1：A与C通信 C获取A的外网IP及端口 2：B与C通信
前段时间项目组接了一个研究所项目，移动端这边需要做一个<em>UDP</em>接收报文的程序APP，其中还涉及到多页面之间收发报文、动态修改地址、端口号等等。原本编写这个收发程序并不难，步骤也比较固定，在网上找了相关例子进行二次开发，可是发现<em>UDP</em>报文接收不到，这其中还是隐藏着某些坑，仅以此篇文章来总结其奥妙精髓。
2018.08.02 最近做的项目要求为：一端为电视端，一端为手机端，实现电视端与手机端通过<em>UDP</em>进行通信。 解释：就是两个机器在同一个局域网内（即两端连接的同一个WiFi），可以通过<em>UDP</em>，一端将信息通过局域网散播出去后，在同一个局域网内的所有设备都能接收到信息，只不过，另一端对接收到的信息进行处理，这样就完成了<em>UDP</em>通信。发送信息方只负责发送信息，另一方只负责接收信息，两方还可以互相发送...
在做一个项目， 有一台android需要实时接受其它客户端的udp<em>数据</em>包(包括在锁屏的状态下)， 我使用了mina框架， 在未锁屏的时候， 是能够正常的接受到<em>数据</em>包的， 但是一旦锁屏了就再也<em>无法</em>接受到
今天遇到一个很神奇的问题。 应用中有一个服务，服务中使用线程池 进行<em>UDP</em>的接收和发送。 但是，当锁屏后，<em>数据</em>无论如何都接收不到，当打开锁屏的时候，<em>数据</em>接收又恢复正常了。 并且，使用电源锁也没有任何效果。 PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE); wl = pm.newWakeLoc
项目用海思做的编解码卡，发送接收rtp/udp流，有两个bug，一直解决不了，都是和丢包相关的 第一个现象是编码卡A和解码卡B搭配使用的时候，log显示丢包，现在已知的情报有： 1、测试的环境是A和B
两台电脑，连接在同一个路由器上。 设发送端电脑为A，接收端为B。server运行在A上，两个客户端client1（使用9012端口）和client2（使用9011端口）运行在B上。 A使用9001端口
/** * 接收<em>数据</em>线程 */ @Override public void run() { // TODO Auto-generated method stub try { while(!isStart); DatagramPacket dPacket = new DatagramPacket(reBuf, LEN); //InetAddress LocalAddr = InetAddress.getLocalHost(); //Log.e(TAG,"IP = "+LocalAddr); /*dSocket = new DatagramSocket(null); dSocket.setReuseAddress(true); dSocket.bind(new InetSocketAddress(LISTENPORT));*/ Log.e(TAG, "server run"); while(isReceiveRun){ /** * udp 监听，当接收到<em>数据</em>则对<em>数据</em>进入处理后发送消息给UI线程，进行更新UI */ Log.e(TAG,"<em>receive</em>"); listenSocket.<em>receive</em>(dPacket); Log.e(TAG,"port = "+dPacket.getPort()+""); if(dPacket.getPort() == SOURPORT) processMessage(dPacket.getData()); //for(int i=0;i * 环境<em>数据</em>：EnvironmentList * 抄表<em>数据</em>：WatermeterList * @param data */ private void processMessage(final byte[] data) { // TODO Auto-generated method stub Log.e(TAG,"data"); byte C = data[0]; int L = data[1]*256+data[2]; int DI = 0; DI |= ((int)data[3]&0xff)<<>4)&0xf)+(CS&0xf)+" L = "+L+" DI = "+DI); if(CS != Check(data,L+4)){ Log.e(TAG,"CS erro"); return; } if(((byte)C != (byte)0xBB)&&((byte)C != (byte)0x3B)){ if(((byte)C == (byte)0xFB)||((byte)C == (byte)0xE3)){//错误应答 switch(DI){ case CONTROL_DI: dataType = CONTROL_TYPE; break; case SEARCH_ENVIRONMENT_DI: break; case SEARCH_LIGHT_DI: break; case SEARCH_SCENE_DI: break; case SEARCH_WATERMETER_DI: break; default: Log.e(TAG,"error DI bit"); return; } //return; }else{//此<em>数据</em>不符合协议 Log.e(TAG,"error protocol"); return; } } //处理正确应答<em>数据</em> switch(DI){ case CONTROL_DI: dataType = CONTROL_TYPE; break; case SEARCH_ENVIRONMENT_DI: dataType = SEARCH_ENVIRONMENT_TYPE; //enable = 1; break; case SEARCH_LIGHT_DI: dataType = SEARCH_LIGHT_TYPE; int len = DATA.length; int nums = len/2; for(int i=0; i); return; } 对接受到的<em>数据</em>进行首字节判断，判断正确更改按键当前状态并改变发送<em>UDP</em><em>数据</em> ，判断失败按键状态不变发送<em>UDP</em><em>数据</em>不变 目前打印不出接收到的<em>数据</em>，不知道哪里出问题了，有人能帮我看看吗？我是android菜鸟
主进程 import android.support.v7.app.ActionBarActivity; import android.annotation.SuppressLint; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.view.Menu; import android.view.MenuItem; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.TextView; import android.widget.Toast; public class YuntuActivity extends ActionBarActivity implements OnClickListener { private TextView adSpeed; private TextView reSpeed; private TextView reTxt; private Button btnHeadCar; private Button btnAgree; private Button btnApply; private Button btnStart; private Button btnExit; //自定义变量 private String remoteIP = null; private int rePort = 0; private int loPort = 0; private <em>UDP</em>Thread reTxtThread = null; private <em>UDP</em>Thread adSpeedThread = null; private <em>UDP</em>Thread reSpeedThread = null; private String sendStr = null;//发送的字符串 private String receStr = null; Handler mhander = new Handler() { public void handleMessage(Message msg) { Bundle bundle =new Bundle(); bundle = msg.getData(); receStr = bundle.getString("info"); reTxt.setText(receStr); } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_yuntu); //初始化UI initUI(); //初始化 init(); reTxtThread = new <em>UDP</em>Thread(mhander); } private void init() { remoteIP = "172.22.130.124"; rePort = 8801; loPort = 8805; } //初始化UI private void initUI() { adSpeed =(TextView)findViewById(R.id.AdSpeed); reSpeed =(TextView)findViewById(R.id.ReSpeed); reTxt =(TextView)findViewById(R.id.reTxt); btnHeadCar =(Button)findViewById(R.id.button1); btnAgree =(Button)findViewById(R.id.button2); btnApply =(Button)findViewById(R.id.button3); btnStart =(Button)findViewById(R.id.button4); btnExit =(Button)findViewById(R.id.button5); } @Override public void onClick(View v) { switch (v.getId()) { //点击 同意入队 按钮 case R.id.button1: sendStr = "you can join in flownteam."; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击 申请入队按钮 case R.id.button2: sendStr = "Can I join in?"; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击申请离队按钮 case R.id.button3: sendStr = "Can I exit?"; if(!sendStr.trim().equals("")) { reTxtThread.sendData(sendStr); } break; //点击开始监听按钮 case R.id.button4: reTxtThread.setReomteIP(remoteIP); reTxtThread.setRePort(rePort); reTxtThread.setLoPort(loPort); boolean connResult = reTxtThread.connectSocket(); if(connResult) { Toast.makeText(getApplicationContext(), "链接建立完毕！", Toast.LENGTH_SHORT).show(); } break; //点击关闭监听按钮 case R.id.button5: reTxtThread.disConnectSocket(); Toast.makeText(getApplicationContext(), "链接已经关闭!", Toast.LENGTH_SHORT).show(); break; default: break; } } } 子线程：接收和发送<em>UDP</em>包 package com.example.cqput_yuntu2; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; import java.text.SimpleDateFormat; import java.util.Date; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.widget.TextView; public class <em>UDP</em>Thread implements Runnable { // 定义变量 private TextView rTextView = null; private String reomteIP = null; private int rePort = 0; private int loPort = 0; private Thread rThread = null; private static String CHARECTER = "UTF-8"; private SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss"); // 接收 private byte[] rBuffer = new byte[1024]; private DatagramSocket rSocket = null; private DatagramPacket rPacket = null; private String rStr = null; // 发送 private DatagramSocket sSocket = null; private DatagramPacket sPacket = null; private byte[] sBuffer = new byte[1024]; public Handler mhandler; public <em>UDP</em>Thread(Handler handler) { mhandler = handler; } @Override public void run() { // 开始接收<em>数据</em> Looper.prepare(); if (Thread.currentThread() == rThread) { System.out.println("------jieshouqian"); rStr = <em>receive</em>Data(); System.out.println("------jieshouhou"); Message toMain = mhandler.obtainMessage(); Bundle bundle = new Bundle(); bundle.putString("info", rStr); toMain.setData(bundle); mhandler.sendMessage(toMain); } ; try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // 开始接收<em>数据</em> private String <em>receive</em>Data() { try { ByteArrayInputStream bais = new ByteArrayInputStream(rBuffer); DataInputStream dis = new DataInputStream(bais); if (rSocket == null) { rSocket = new DatagramSocket(8805); } if (rPacket == null) { rPacket = new DatagramPacket(rBuffer, rBuffer.length); } System.out.println("----rece"); rSocket.<em>receive</em>(rPacket); System.out.println("------receHou"); rStr = dis.readUTF().trim(); System.out.println("------jieBeg"); rStr = String.format("[%s:%d//%s]%s", rPacket.getAddress() .getHostAddress(), rPacket.getPort(), sdf .format(new Date()), rStr); return rStr; } catch (Exception e) { e.printStackTrace(); System.out.println("-----------------recvdata error:" + e.getMessage()); } return null; } // 建立连接 public boolean connectSocket() { boolean result = false; // 开启一个新的线程 startThread(); System.out.print("监听线程开启"); result = true; return result; } // 关闭连接 public void disConnectSocket() { if (rSocket != null) { rSocket.close(); rSocket = null; } if (rPacket != null) { rPacket = null; } // 关闭线程 stopThread(); } // 关闭线程 private void stopThread() { if (rThread != null) { rThread.stop(); rThread = null; } } // 开启新的线程 private void startThread() { if (rThread == null) { rThread = new Thread(this); rThread.start(); } } // 开始发送<em>数据</em> public void sendData(String sendStr) { try { // 包装<em>数据</em> ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); dos.writeUTF(sendStr); sBuffer = baos.toByteArray(); if (sSocket == null) { sSocket = new DatagramSocket(); } if (sPacket == null) { sPacket = new DatagramPacket(sBuffer, sBuffer.length, InetAddress.getByName(reomteIP), rePort); } sSocket.send(sPacket); sSocket.close(); sSocket = null; sPacket = null; } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); sSocket.close(); sSocket = null; sPacket = null; System.out.println("senddata error:" + e.getMessage()); } } public void setReomteIP(String reomteIP) { this.reomteIP = reomteIP; } public void setRePort(int rePort) { this.rePort = rePort; } public void setLoPort(int loPort) { // this.loPort = loPort; } }
最近项目中遇到了一个问题, 就是用 <em>Android</em> 作为客户端给PC发送<em>UDP</em> 报文 并且接收返回的消息. 如果在局域网下是可以的. 然后服务端放到 电信服务器下 然后使用移动的网络进行连接 只能发送
问题： 同一套程序在中兴手机和华为手机上可以接收到<em>UDP</em>广播报文，但在HTC手机上却接收不到？ 问题原因：（仅猜测而已，未经过验证） 手机开启<em>UDP</em>广播功能不仅耗电，而且占用系统资源。可能有些手机厂家默认把这个功能给关掉了， 你若想要用手机来发送接收<em>UDP</em>报文，得先申请，才能使用这个功能。 具体如何申请和释放： 1、可先在oncreate()方法里面实例化一个WifiManag
android不能使用udp获取<em>数据</em> 如果你要通过wifi在内网里，用android手机通过udp发送<em>数据</em>到pc上，并在pc上通过java程序将<em>数据</em>返回到手机上，但是确<em>无法</em>获取<em>数据</em>，今天我也遇到了这个问题，如今已经解决，现在分享给大家： 1、在你的电脑里也许有两块网卡 2、你是通过wifi向pc发送<em>数据</em>的 3、pc默认选择第一块网卡发送<em>数据</em>（通过 ifconfig(linux
以太网(Ethernet)<em>数据</em>帧的长度必须在46-1500字节之间,这是由以太网的物理特性决定的. 这个1500字节被称为链路层的MTU(最大传输单元). 但这并不是指链路层的长度被限制在1500字节,其实这这个MTU指的是链路层的<em>数据</em>区. 并不包括链路层的首部和尾部的18个字节. 因为IP<em>数据</em>报的首部为20字节,所以IP<em>数据</em>报的<em>数据</em>区长度最大为1480字
在项目中用到了<em>UDP</em>通讯，大部分情况下收发正常。 但是长时间情况下出现一些问题，我一分钟有心跳包发给服务端，服务端也可以收到，但是服务端发给客户端的<em>数据</em>包不能正常接收，接收端接收<em>数据</em>后发给接收<em>数据</em>队列
WIFI芯片发送广播<em>UDP</em><em>数据</em>给手机，经常出现安卓<em>UDP</em>接收<em>数据</em> 经常失败 解决方法： 1）WifiManager.MulticastLock 对象lock 失败，还是不行 一、有的手机不能直接接收<em>UDP</em>包，可能是手机厂商在定制Rom的时候把这个功能给关掉了。 1、可先在oncreate()方法里面实例化一个WifiManager.M
<em>Android</em>通过广播的方式来发送和接收<em>数据</em>，从而进行手机间的通信。发送方：public class SendToAIUIUtils { private static InetAddress mAddress; private static DatagramSocket socket = null; private static String ip = "255.255.25
<em>UDP</em>丢包原因 一、主要丢包原因 1、接收端处理时间过长导致丢包：调用recv方法接收端收到<em>数据</em>后，处理<em>数据</em>花了一些时间，处理完后再次调用recv方法，在这二次调用间隔里,发过来的包可能丢失。对于这种情况可以修改接收端，将包接收后存入一个缓冲区，然后迅速返回继续recv。 2、发送的包巨大丢包：虽然send方法会帮你做大包切割成小包发送的事情，但包太
用<em>UDP</em>传输视频文件，VC发送<em>数据</em>到安卓端，安卓端监听端口接收<em>数据</em>，采用网线直连，排除网络原因造成的丢包。当VC发送<em>数据</em>延时50ms（大概几百K每秒的速度发包），JAVA端能正确接收。可是不延时50ms发送时（大概2M/S的速度发包）JAVA端接收就出现丢包。JAVA开了两个线程，一个线程接收并放到缓冲队列，另一个线程从缓冲队列取出<em>数据</em>写入U盘。缓冲队列大小也比发送的文件要大，也不可能是缓冲队列不够大的问题。希望得到大神指点，代码如下： void CSendudpDlg::OnBUTTONSendfile() { SOCKET sockClient=socket(AF_INET,SOCK_DGRAM,0); SOCKADDR_IN addSrv; CString str; CTypeChange myChang; unsigned char xbuf[4096]; int len; m_portdest=8899; m_serverIP="192.168.1.4"; HANDLE hfile; hfile=CreateFile("D:\\amy.mp4", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); addSrv.sin_addr.S_un.S_addr = inet_addr(m_serverIP); addSrv.sin_family = AF_INET; addSrv.sin_port = htons(m_portdest); DWORD dwstart,dwend,dwrate; DWORD file_len=19025412; int npack=file_len/4063; DWORD ret,lret; int num=0; while(npack--) { memset(&xbuf,0,sizeof(xbuf)); ret=ReadFile(hfile,xbuf,4063,&lret,NULL); if( lret == 0) { SetFilePointer(hfile,0,0,FILE_BEGIN); continue; } xbuf[1]=4077/256; //包头信息 xbuf[2]=4077%256; xbuf[3]=(num/256)/256; xbuf[4]=(num/256)%256; xbuf[7]=num%256; ::Sleep(50); sendto(sockClient,(char*)xbuf,4096,0,(SOCKADDR*)&addSrv,sizeof(SOCKADDR)); num++; } cprintf("end!!!!!!!\n"); closesocket(sockClient); } 安卓端： package com.example.util; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.SocketException; import java.util.Arrays; import android.os.Environment; import android.util.Log; import com.example.net.Invoker; /** * 封装了<em>数据</em>生产工厂，该工厂中提供了生产和消费方法 * * @author Jry * */ public class Factory { private int read_loc; private int write_loc; private int buffer_len; private int content_len; private int buffers_count; private byte[] buffers; private int[] flags; private File file = null; private String filePath = null; private RandomAccessFile raf = null; private static final String CRLF = "\r\n"; private DatagramSocket datagramSocket = null; private DatagramPacket dataPacket = null; private Object read_lock = new Object(); private Object write_lock = new Object(); private static Factory instance = null; private int last_pos; private int[][] loc_map = null; private Invoker invoker = null; public static Factory newInstance() { if (null == instance) { synchronized (Factory.class) { if (null == instance) { instance = new Factory(); } } } return instance; } private Factory() { initialize(); invoker = Invoker.getInstance(); } private void initialize() { last_pos = 0; read_loc = 0; write_loc = 0; buffer_len = 4096; content_len = 4063; buffers_count = 1024 * 10; flags = new int[buffers_count]; loc_map = new int[4063][256]; buffers = new byte[buffer_len * buffers_count]; Arrays.fill(flags, 0); for (int[] temp : loc_map) { Arrays.fill(temp, 0); } // 设置输出流 filePath = Environment.getExternalStorageDirectory().getPath() + "/video/test.mp4"; file = new File(filePath); if (file.exists()) { Log.i("123", "file has been existed !!!" + CRLF); if (file.delete()) { Log.i("123", "file has benn deleted!!!" + CRLF); } } try { if (file.createNewFile()) { Log.i("123", "成功创建新文件!!!" + CRLF); } } catch (IOException e2) { e2.printStackTrace(); } // 预分配文件所占的磁盘空间，磁盘中会创建一个指定大小的文件 try { raf = new RandomAccessFile(filePath, "rw"); raf.setLength(19025412); // 预分配 19025412 的文件空间 raf.close(); } catch (FileNotFoundException e1) { e1.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } // 设置socket的监听端口 try { datagramSocket = new DatagramSocket(8899); // datagramSocket.setSoTimeout(10000); Log.i("123", "datagramsocket start successed!!!"); } catch (SocketException e) { Log.i("123", "datagramsocket start failed!!!"); e.printStackTrace(); } } //计数当前总共收到了多少个<em>数据</em>包 private int j = 0; public void create() { while (flags[write_loc] == 1) { synchronized (read_lock) { try { read_lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } byte[] buffer = new byte[buffer_len]; byte[] <em>receive</em>Byte = new byte[buffer_len]; dataPacket = new DatagramPacket(<em>receive</em>Byte, buffer_len); try { datagramSocket.<em>receive</em>(dataPacket); Log.i("123", "收到了<em>数据</em>包 ！！！" + " dataPacket.getLength() ==" + dataPacket.getLength()); int len = dataPacket.getLength(); if (len == buffer_len) { buffer = dataPacket.getData(); System.arraycopy(buffer, 0, buffers, write_loc * buffer_len, buffer_len); Log.i("123", "写入缓存<em>数据</em>的长度------" + len + "------" + write_loc + CRLF); Log.i("123", "当前受到包的<em>数据</em>包的数量是------" + (++j) + CRLF); flags[write_loc] = 1; write_loc = (write_loc + 1) % buffers_count; synchronized (read_lock) { read_lock.notifyAll(); } } } catch (IOException e) { e.printStackTrace(); } } public void consume() { while (flags[read_loc] == 1) { try { raf = new RandomAccessFile(filePath, "rw"); int start_loc = buffer_len * read_loc; /* int offset = i*buffer_len; raf.seek(offset); raf.write(buffers, start_loc, buffer_len); Log.i("123", "写入文件<em>数据</em>的长度*****************" + buffer_len +"read_loc == " + read_loc+CRLF); */ int section = (buffers[start_loc + 7] & 0x0FF); int module = (buffers[start_loc + 3] & 0x0FF) * 256 + (buffers[start_loc + 4] & 0x0FF); int len = (buffers[start_loc + 1] & 0x0FF) * 256 + (buffers[start_loc + 2] & 0x0FF); int cur_pos = module * 256 + section; Log.i("123", "module == " + module + ", section == " + section + ", len == " + len + CRLF); if (loc_map[module][section] == 0) { // 补包的代码 // if (!((last_pos + 1) == cur_pos)) { // int gap = cur_pos - last_pos - 1; // for (int i = 0; i < gap; i++) { // Command command = new // ConcreteCommand(<em>UDP</em>Sender.getInstance()); // command.setOrderNum(++last_pos); // invoker.addCommand(command); // } // invoker.executeCommand(); // } loc_map[module][section] = 1; // 表示该包号的包已经接收 raf.seek(cur_pos * content_len); raf.write(buffers, start_loc + 13, len - 14); last_pos = cur_pos; Log.i("123", "写入文件<em>数据</em>的长度*****************" + (len - 14) + "*******" + read_loc + CRLF); } flags[read_loc] = 0; read_loc = (read_loc + 1) % buffers_count; synchronized (write_lock) { write_lock.notifyAll(); } } catch (IOException e) { e.printStackTrace(); } finally { try { raf.close(); } catch (IOException e) { e.printStackTrace(); } } } synchronized (read_lock) { try { read_lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } }
<em>UDP</em>的<em>数据</em>发送是按照包来发送的。也就是说，你要先把你的<em>数据</em>包装成一个DatagramPacket，然后发送出去。 相比起TCP，<em>UDP</em>实现起来逻辑更简单(收发方逻辑几乎是相同的)，开销也更小，在一般通讯时，主要利用<em>UDP</em>来发送消息是个不错的选择；不过我们还需要一点辅助手段来处理<em>UDP</em>丢包的问题。
udp丢包 又是udp丢包 原创 什么会导致udp丢包呢，我这里列举了如下几点原因： 1.调用recv方法接收端收到<em>数据</em>后，处理<em>数据</em>花了一些时间，处理完后再次调用recv方法，在这二次调用间隔里,发过来的包可能丢失。对于这种情况可以修改接收端，将包接收后存入一个缓冲区，然后迅速返回继续recv。 2.发送的包巨大丢包。虽然send方法会帮你做大包切割成小包发送的事情，但包太大也不行。例
最近在做一个项目,在这之前,做了个验证程序.发现客户端连续发来1000个1024字节的包,服务器端出现了丢包现象.纠其原因,是服务端在还未完全处理掉<em>数据</em>,客户端已经<em>数据</em>发送完毕且关闭了.我用过sleep(10),暂时解决这个问题,但是这不是根本解决办法,如果<em>数据</em>量大而多,网络情况不太好的话,还是有可能丢失. 你试着用阻塞模式吧...select...我开始的时候好像也遇到过..不过改为阻...
正常情况下DatagramSocket.<em>receive</em>()是阻塞到收到包为止，我想设置一个timeout时间，比如一秒，超过一秒就解除阻塞，继续执行下面的语句。 不要跟我说setSoTimeout()
接收方创建步骤： 1. 创建一个DatagramSocket对象，并指定监听的端口号 DatagramSocket socket = new DatagramSocket (4567); 2. 创建一个byte数组用于接收 byte data[] = new byte[1024]; 3. 创建一个空的DatagramPackage对象 DatagramPackage packag
之前看网上说用发送命令行的方式获取客户端的mac地址，具体方法不复述了。 其中用到这个<em>receive</em>()方法，朋友在测试的时候发现会无响应，发现是window的系统防火墙开启以后出现的。 <em>无法</em>保证每个用户都是关闭系统防火墙的，所以看了一下api，发现一个解决方法。 直接贴代码看吧 DatagramSocket ds=new DatagramSocket(); DatagramP
在接收广播的时候，如果服务端没有开启的话，<em>receive</em>方法会进入阻塞状态。我想通过获取当前的状态添加一个提示。 不然在客户端开启，服务端没开启的情况下，客户端就一直等待，也没个提示，这种体验很不好。
新手一枚，最近做一个从安卓摄像头传输实时图像到PC端。 安卓方面用<em>UDP</em>传输，采用图片的方式一帧一帧传输，安卓端发送<em>数据</em>包是大概每隔200ms一次，每次大概10KB左右。 PC端采用如下方式接收。wh
最近做了一个关于udp的项目，分为移动端和服务器端，移动端用来给服务器发送<em>数据</em>同时接收服务器返回的<em>数据</em>，服务器当然是接收客户端<em>数据</em>了，然后返回一定的信息。期间遇到了很多问题，但最后还是解决了，所以想和他人分享一下下，希望可以帮到一些开发的朋友。 做这个项目时，在网上也是查了一些资料，发现很多朋友在客户端接收服务器返回<em>数据</em>时出了问题，发送几乎没有什么问题。 这些问题的发生
public static String xinxis() { string sx = null; UdpClient udpp = new UdpClient(bdukou); udpp.Conne
有一段时间没有写博客了，差不多两个月了，怎么说呢，这就是那个叫“三分热度”吧，我的三分热度时间不长，但是呢，这个三分热度时不时的来一次，这也是一个小幸运吧。今天来聊聊javaEE 的知识，其实也是网络通信的知识，现在先从一个小小的demo开始入手，慢慢的走向项目实战。我们今天的小demo有两个类，分别代表着发送端和接收端，这里主要的两个类是DatagramSocket和DatagramPacket，
1、NAT（Network Address Translator）介绍 NAT有两大类，基本NAT和NAPT。 1.1、基本NAT 静态NAT：一个公网IP对应一个内部IP，一对一转换 动态NAT：N个公网IP对应M个内部IP，不固定的一对一转换关系 1.2、NAPT（Network Address/Port Translator） 现在基本使用这种，又分为对称和锥型N...
几年前做过一个简单的nat 打洞的项目， 当时自己做了个简单的总结。 希望对你有些帮助。 p2p有很多种， 有些是利用supernode, 有些是nat 打洞， 有些是两者结合。 下面说的p2p专指nat打洞。 P2P通信技术由于根据不同的网络环境，可能采取不同的策略。优秀的P2P通信软件，在做通信 之前，首先都要检测自己目前所处的网络环境。检测网络环境的内容包括: [1]
装有网络调试助手的 两台手机和电脑 电脑公网IP 219.134.15.219 打开<em>UDP</em>端口 52302 手机1 117.136.12.180:4468 连接电脑成功并保持20s心跳连接 手机2 1
最近需要做一个非局域网通信的东西。需要用到打洞技术。 于是我按照网上说的做了一个非局域网打洞的程序。 但是，不管怎么样。A和B得到对方的NAT地址后始终<em>无法</em>收到对方的消息。 有没有高手能来看一下，到底
参考文章（VC实现）：http://www.vckbase.com/document/viewdoc/?id=1773内容概述：在p2p通信领域中，由NAT(Network Address Translation，网络地址转换)引起的问题已经众所周知了,它会导致在NAT内部的p2p客户端在无论以何种有效的公网ip都<em>无法</em>访问的问题。虽然目前已经发展出多种穿越NAT的技术,但相关的技术文档却很少，
TCP打洞和<em>UDP</em>打洞的区别
client-A client-B server-C 目的：A想跟B通信 1：A与C通信 C获取A的外网IP及端口 2：B与C通信 C获取B的外网IP及端口 3：A给C获取到B的IP端口发消息（被丢弃） 4：B给C获取到A的IP端口发消息（被丢弃） 5: 之后A跟B就能直接通信了
现实环境：有两个客户端甲、乙需要通信，它们处于两个不同的子网。 解决方案：udp打洞（一般路由器都支持） 解决过程： 1、准备一台服务器，放在公网上，与客户端甲和乙通信，记录客户端甲和乙的Ip和端口信息，这些IP和端口并非甲和乙在内网的IP和端口，而是通过NAT方式映射到路由器上的IP和端口。 2、客户端甲向服务器发送udp消息，请求和客户端乙通信。 3、服务器向客户端甲发送消息，消息内
一直听人家说<em>UDP</em>打洞，或者你想实现两个局域网之间进行通信，那么，看一下<em>UDP</em>打洞原理吧，也许能帮到你。
本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明. 许多P2P软件比如SKYPE,QQ,电驴之类需要不同内网的两台机子进行通信,而路由器的NAT机制决定了内网访问外网容易,而外网访问内网困难,那如何才能做到这一点呢?有办法------打洞! 具体实现方法需要一台服务器,现在假设两台内网PC,A和B想用端口40000通信,网关分别为NATA,NAT...
什么是打洞，为什么要打洞 由于Internet的快速发展 IPV4地址不够用，不能每个主机分到一个公网IP 所以使用NAT地址转换。 下面是我在网上找到的一副图 一般来说都是由私网内主机（例如上图中“电脑A-01”）主动发起连接，<em>数据</em>包经过NAT地址转换后送给公网上的服务器（例如上图中的“Server”），连接建立以后可双向传送<em>数据</em>，NAT设备允许私网内主机主动向公网内主机发送<em>数据</em>,但却...
现在的手机厂商都会做深度优化功能，在手机灭屏的时候，第三方的应用会被挂起或者是kill掉。 目前自己做了一个即时通讯聊天的<em>Android</em> App，但是在华为手机上灭屏的时候进程就被挂起了，这样就<em>无法</em>接受到别人发送过来的信息。想请问下大神们有没有什么好的处理方式，让程序在手机灭屏的时候每隔一段时间唤醒一次。 我看华为的手机设置里会为微信支付宝等应用提供定时唤醒的功能，第三方其他应用就没有提供这个定时唤醒的功能。不知道对于这种小范围的即时通信工具要如何做
项目要做一个接收广播消息的功能，收到对应消息做刷新一下界面。现在的问题是，有时候能收到<em>数据</em>，有时又收不到，测试机器台电（平板）P88，P98这两个机器经常收不到<em>数据</em>；手机（红米、康佳）却几乎能全部收到
实测，和机型有关，有的机型完全没问题。 但是有的机型，表现为锁屏后，<em>UDP</em>接收立即被休眠，<em>无法</em>接收<em>UDP</em>消息。锁屏状态下只要点亮屏幕，就会正常。 <em>UDP</em>发送，启动一个线程，每几秒发送一个<em>UDP</em>包，锁屏
如题，<em>Android</em>锁屏后<em>无法</em>接受<em>UDP</em>广播，我测试了一下锁屏后线程还是有在工作但是<em>UDP</em>广播接收不到。求大神赐教
设备：客户端，服务端 机制：<em>UDP</em> 心跳思路： 1.自检，检测自身是否连接网络 2.检测对方是否发来信息，自身是否接收到 ? 代码片段，双击复制 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17
1.由于传输协议基于protocol buffer，接收到的<em>数据</em>包是动态变化的，而java<em>数据</em>包接收要先定义byte【】大小，这样接收到的<em>数据</em>报长度变为固定了，于是接收到的<em>数据</em>报在反序列化的时候屡屡报错。。。。。。郁闷死 解决方法：利用DatagramPacket.getLength()可以截获实际<em>数据</em>报大小，再重新定义一块该大小的byte【】反序列化就可以了。 2.android模拟器在用udp接收<em>数据</em>的时候老接收不到<em>数据</em>，这个问题搞得我也焦头烂
MSDN：Receive方法将阻塞，直到<em>数据</em>报从远程主机到达为止。 可如若远程主机无<em>数据</em>报返回，或者<em>数据</em>报丢失，那岂不是Receive方法将永远等下去了么？如何解决此问题，或设置超时时间？盼答，非常感
关于<em>UDP</em>通信其实可以不用多做累述，多数像我一样的朋友在此基础上也只是为了应用，需要了解下该了解的就可以了，具体的想要对这个协议研究深入的，可以自己努力！我这儿只做<em>Android</em>客户端的应用实现，注意是客户端，不是服务器，那么服务器怎么实现呢？下次有空再写服务器的实现，先看客户端。 我们既然是在<em>Android</em>下实现的，我们第一件事情肯定是想好我们大概想做成什么样子，那么为了简单，我在这是这样
最近做功能需要用到使用<em>UDP</em>协议和服务器进行通信，之前没有接触这一块，所以花了些时间了解和实现，这里做一下记录和分享。
http://book.51cto.com/art/201203/322540.htm 17.4.2 使用DatagramSocket发送、接收<em>数据</em>（1） Java使用DatagramSocket代表<em>UDP</em>协议的Socket，DatagramSocket本身只是码头，不维护状态，不能产生IO流，它的唯一作用就是接收和发送<em>数据</em>报，Java使用DatagramPacket来代表<em>数据</em>报，Datagr
参考，感谢两位大哥的文章 http://www.cnblogs.com/liqw/p/4867657.html https://blog.csdn.net/u012106397/article/details/51492867 udp很早就听说过，但是由于其是面向无连接的协议，因此一直很少用到。但是在一些即时通讯方面，由于对延时有较高的要求，因此还是会使用到。 1.<em>Android</em>...
ANDROID菜鸟一名，老板要求用<em>UDP</em>通信，根据相关教程写的下面代码，能够发送消息到服务器，但服务器不能接受消息。求大神帮忙看看 public class MainActivity extends
可在oncreate中添加如下WifiManager manager = (WifiManager) this .getSystemService(Context.WIFI_SERVICE); lock = manager.createMulticastLock("test wifi");并在调用.<em>receive</em>前调用lock.acquire();
socket = new DatagramSocket(Integer.parseInt(edtReceivePort .getText().toString())); byte[] inBuf = new byte[100]; listenStatus = true; while (listenStatus) { DatagramPacket inPacket=new DatagramPacket(inBuf,inBuf.length); socket.<em>receive</em>(inPacket);// <em>receive</em>Info = new String(inPacket.getData()); } catch (Exception e) { // TODO Auto-generated catch block } } 我打断点看过，如果我发三个数字123，接收【1，2，3，0，0，0，0，0，0，0，0，】这样的，我循环发送，就接收不进来，只能收到一次，大家有什么解决的好方法吗？我想循环接收，循环显示的效果！要怎么做呢？ 我在网上看到说要加socket.close();但是试过好像不行，大家有什么好方法！
今年，我也32了 ，为了不给大家误导，咨询了猎头、圈内好友，以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助，记得帮我点赞哦。 目录： 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时，拿着傲人的工资，想着好好干，以为我们的人生是这样的： 等真到了那一天，你会发现，你的人生很可能是这样的： ...
程序员在一个周末的时间，得了重病，差点当场去世，还好及时挽救回来了。
互联网公司工作，很难避免不和黑客们打交道，我呆过的两家互联网公司，几乎每月每天每分钟都有黑客在公司网站上扫描。有的是寻找 Sql 注入的缺口，有的是寻找线上服务器可能存在的漏洞，大部分都...
“亚马逊丛林里的蝴蝶扇动几下翅膀就可能引起两周后美国德州的一次飓风……” 这句人人皆知的话最初用来描述非线性系统中微小参数的变化所引起的系统极大变化。 而在更长的时间尺度内，我们所生活的这个世界就是这样一个异常复杂的非线性系统…… 水泥、穹顶、透视——关于时间与技艺的蝴蝶效应 公元前3000年，古埃及人将尼罗河中挖出的泥浆与纳特龙盐湖中的矿物盐混合，再掺入煅烧石灰石制成的石灰，由此得来了人...
最近有个老铁，告诉我说，上班一个月，后悔当初着急入职现在公司了。他之前在美图做手机研发，今年美图那边今年也有一波组织优化调整，他是其中一个，在协商离职后，当时捉急找工作上班，因为有房贷供着，不能没有收入来源。所以匆忙选了一家公司，实际上是一个大型外包公司，主要派遣给其他手机厂商做外包项目。**当时承诺待遇还不错，所以就立马入职去上班了。但是后面入职后，发现薪酬待遇这块并不是HR所说那样，那个HR自...
昨天看到一档综艺节目，讨论了两个话题：（1）中国学生的数学成绩，平均下来看，会比国外好？为什么？（2）男生的数学成绩，平均下来看，会比女生好？为什么？同时，我又联想到了一个技术圈经常讨...
提到“程序员”，多数人脑海里首先想到的大约是：为人木讷、薪水超高、工作枯燥…… 然而，当离开工作岗位，撕去层层标签，脱下“程序员”这身外套，有的人生动又有趣，马上展现出了完全不同的A/B面人生！ 不论是简单的爱好，还是正经的副业，他们都干得同样出色。偶尔，还能和程序员的特质结合，产生奇妙的“化学反应”。 @Charlotte：平日素颜示人，周末美妆博主 大家都以为程序媛也个个不修边幅，但我们也许...
有个好朋友ZS，是技术总监，昨天问我：“有一个老下属，跟了我很多年，做事勤勤恳恳，主动性也很好。但随着公司的发展，他的进步速度，跟不上团队的步伐了，有点...
私下里，有不少读者问我：“二哥，如何才能写出一份专业的技术简历呢？我总感觉自己写的简历太烂了，所以投了无数份，都石沉大海了。”说实话，我自己好多年没有写过简历了，但我认识的一个同行，他在阿里，给我说了一些他当年写简历的方法论，我感觉太牛逼了，实在是忍不住，就分享了出来，希望能够帮助到你。 01、简历的本质 作为简历的撰写者，你必须要搞清楚一点，简历的本质是什么，它就是为了来销售你的价值主张的。往深...
今天给你们讲述一个外包程序员的幸福生活。男主是Z哥，不是在外包公司上班的那种，是一名自由职业者，接外包项目自己干。接下来讲的都是真人真事。 先给大家介绍一下男主，Z哥，老程序员，是我十多年前的老同事，技术大牛，当过CTO，也创过业。因为我俩都爱好喝酒、踢球，再加上住的距离不算远，所以一直也断断续续的联系着，我对Z哥的状况也有大概了解。 Z哥几年前创业失败，后来他开始干起了外包，利用自己的技术能...
本文介绍一些C++的两个新特性，它们虽然微小，但对你的编程十分重要 一、Template表达式内的空格 C++11标准之前建议在“在两个template表达式的闭符之间放一个空格”的要求已经过时了 例如： vector<list<int> >; //C++11之前 vector<list<int>>; //C++11 二、nullptr ...
场景 日常开发，if-else语句写的不少吧？？当逻辑分支非常多的时候，if-else套了一层又一层，虽然业务功能倒是实现了，但是看起来是真的很不优雅，尤其是对于我这种有强迫症的程序"猿"，看到这么多if-else，脑袋瓜子就嗡嗡的，总想着解锁新姿势：干掉过多的if-else！！！本文将介绍三板斧手段： 优先判断条件，条件不满足的，逻辑及时中断返回； 采用策略模式+工厂模式； 结合注解，锦...
大家现在应该都对Springboot很熟悉，但是你对他的启动原理了解吗？
有小伙伴问松哥这个问题，他在上海某公司，在离职了几个月后，前公司的领导联系到他，希望他能够返聘回去，他很纠结要不要回去？ 俗话说好马不吃回头草，但是这个小伙伴既然感到纠结了，我觉得至少说明了两个问题：1.曾经的公司还不错；2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说，松哥之前也有过类似的经历，今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点，就是离职了也没必要和老东家弄的苦...
不知道是不是只有我这样子，还是你们也有过类似的经历。 上学的时候总有很多光辉历史，学年名列前茅，或者单科目大佬，但是虽然慢慢地长大了，你开始懈怠了，开始废掉了。。。 什么？你说不知道具体的情况是怎么样的？ 我来告诉你： 你常常潜意识里或者心理觉得，自己真正的生活或者奋斗还没有开始。总是幻想着自己还拥有大把时间，还有无限的可能，自己还能逆风翻盘，只不是自己还没开始罢了，自己以后肯定会变得特别厉害...
二哥，有个事想询问下您的意见，您觉得应届生值得去外包吗？公司虽然挺大的，中xx，但待遇感觉挺低，马上要报到，挺纠结的。
当HR压你价，说你只值7K时，你可以流畅地回答，记住，是流畅，不能犹豫。 礼貌地说：“7K是吗？了解了。嗯~其实我对贵司的面试官印象很好。只不过，现在我的手头上已经有一份11K的offer。来面试，主要也是自己对贵司挺有兴趣的，所以过来看看……”（未完） 这段话主要是陪HR互诈的同时，从公司兴趣，公司职员印象上，都给予对方正面的肯定，既能提升HR的好感度，又能让谈判气氛融洽，为后面的发挥留足空间。...
HashMap底层实现原理，红黑树，B+树，B树的结构原理 Spring的AOP和IOC是什么？它们常见的使用场景有哪些？Spring事务，事务的属性，传播行为，<em>数据</em>库隔离级别 Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringMVC的工作原理，SpringBoot框架的优点，MyBatis框架的优点 SpringCould组件有哪些，他们...
面试阿里p7被问到的问题(当时我只知道第一个)：@Conditional是做什么的?@Conditional多个条件是什么逻辑关系？条件判断在什么时候执...
最近面试了一个31岁8年经验的程序猿，让我有点感慨，大龄程序猿该何去何从。
二本的读者，在老东家不断学习，最后逆袭
说实话，自己的算法，我一个不会，太难了吧
已经连续五年参加大厂校招、社招的技术面试工作，简历看的不下于万份 这篇文章会用实例告诉你，什么是差的程序员简历！ 疫情快要结束了，各个公司也都开始春招了，作为即将红遍大江南北的新晋UP主，那当然要为小伙伴们做点事（手动狗头）。 就在公众号里公开征简历，义务帮大家看，并一一点评。《启舰：春招在即，义务帮大家看看简历吧》 一石激起千层浪，三天收到两百多封简历。 花光了两个星期的所有空闲时...
我们都玩过Windows操作系统中的经典游戏扫雷（Minesweeper），如果把质数当作一颗雷，那么，表格中红色的数字哪些是雷（质数）？您能找出多少个呢？文中用列表的方式罗列了10000以内的自然数、质数（素数），6的倍数等，方便大家观察质数的分布规律及特性，以便对算法求解有指导意义。另外，判断质数是初学算法，理解算法重要性的一个非常好的案例。
正确选择比瞎努力更重要！
大厂竟然要考我SSO，卧槽。
作者 | 伍杏玲出品 | CSDN（ID：CSDNnews）格子衬衫、常掉发、双肩包、修电脑、加班多……这些似乎成了大众给程序员的固定标签。近几年流行的“跨界风”开始刷新人们对程序员的...
来看几个问题想不想月薪超过5万？想不想进入公司架构组？想不想成为项目组的负责人？想不想成为spring的高手，超越99%的对手？那么本文内容是你必须要掌握的。本文主要详解bean的生命...
VMware.Workstation.v7.1.4 相关下载链接：[url=//download.csdn.net/download/ruofeng216/3748831?utm_source=bbsseo]//download.csdn.net/download/ruofeng216/3748831?utm_source=bbsseo[/url]
手机进销存的主窗体及权限代码888888******** 相关下载链接：[url=//download.csdn.net/download/currency00001/7254235?utm_source=bbsseo]//download.csdn.net/download/currency00001/7254235?utm_source=bbsseo[/url]
相当不错呢！很好的毕业设计啊~ 是用vb+sql编写的！ 相关下载链接：[url=//download.csdn.net/download/guanchao7374/674164?utm_source=bbsseo]//download.csdn.net/download/guanchao7374/674164?utm_source=bbsseo[/url]
