udp缓存
❶ windows下怎么修改UDP缓存
要不然你就用win32api重写一遍
要不然你就去装一个cygwin来编译（比较推荐这个选择
否则这一类的代码你只能在linux环境下使用了（考虑下用虚拟机吧……
❷ UDP中将struct skb_buff作为缓存区 具体如何使用
一. SKB_BUFF的基本概念
1. 一个完整的skb buff组成
(1) struct sk_buff--用于维护socket buffer状态和描述信息
(2) header data--独立于sk_buff结构体的数据缓冲区，用来存放报文分组，使各层协议的header存储在连续的空间中，以方便协议栈对其操作
(3) struct skb_shared_info --作为header data的补充，用于存储ip分片，其中sk_buff *frag_list是一系列子skbuff链表，而frag[]是由一组单独的page组成的数据缓冲区
❸ udp Socket 发送缓冲区 最大可以为多大
internet上的标准mtu值为576字节,所以我建议在进行internet的udp编程时.最好将udp的数据长度控件在548字节(576-8-20)以内.
ipv4协议规定ip层的最小重组缓冲区大小为576！所以，建议udp包不要超过这个大小，而不是因为internet的标准mtu是576！
❹ 求助如何清空udpclient发送的缓存区
通过Socket 发送接收消息遇到个问题C# codeSocket newSocket = socket.Accept();newSocket.Receive(messages);获取消息没问题 但是总有缓存区无法清空的问题比如说我先发一句: 我是中国人服务端能正确接收到这句消息: 我是中国人这边再发送一个...
❺ linux下怎么设置udp接收缓存最大值
vi /etc/sysctl.conf
增加或修改 net.ipv4.udp_mem项
net.ipv4.udp_mem = min pressure max
再设一下 net.ipv4.udp_rmem_min
具体含义man udp 查看
完成后执行 sysctl -p 生效
❻ java使用UDP 如果我定义了一个1024byte的缓存，而接收到的只有16个byte剩余的怎么处理
byte[] b = new byte[1024];
int len = 输入流.read(b)://从输入流中读取数据装填到数组b中，len保存的是读到的有效字节数
while( len != - 1 ){ //为-1表示没有数据可读
String str = new String(b, 0, len); //把装数字的数组中本次读到的数据new成string
或者
输出流.write( b, 0, len); //向输出流中写len个字节数据。剩下的你不用管它。
}
记住，len记录了每次读到的有效字节个数，如果接收的只有16个，那么你只用取16个拿出来用，就是准确的数据。
❼ tcp和udp的特点和区别
TCP协议的主要特点
（1）TCP是面向连接的运输层协议；
（2）每一条TCP连接只能有两个端点（即两个套接字），只能是点对点的；
（3）TCP提供可靠的传输服务。传送的数据无差错、不丢失、不重复、按序到达；
（4）TCP提供全双工通信。允许通信双方的应用进程在任何时候都可以发送数据，因为两端都设有发送缓存和接受缓存；
（5）面向字节流。虽然应用程序与TCP交互是一次一个大小不等的数据块，但TCP把这些数据看成一连串无结构的字节流，它不保证接收方收到的数据块和发送方发送的数据块具有对应大小关系，例如，发送方应用程序交给发送方的TCP10个数据块，但就受访的TCP可能只用了4个数据块久保收到的字节流交付给上层的应用程序，但字节流完全一样。
UDP协议特点
（1）UDP是无连接的传输层协议；
（2）UDP使用尽最大努力交付，不保证可靠交付；
（3）UDP是面向报文的，对应用层交下来的报文，不合并，不拆分，保留原报文的边界；
（4）UDP没有拥塞控制，因此即使网络出现拥塞也不会降低发送速率；
（5）UDP支持一对一一对多多对多的交互通信；
（6）UDP的首部开销小，只有8字节。
TCP和UDP的区别
(1)TCP是可靠传输,UDP是不可靠传输;
(2)TCP面向连接,UDP无连接;
(3)TCP传输数据有序,UDP不保证数据的有序性;
(4)TCP不保存数据边界,UDP保留数据边界;
(5)TCP传输速度相对UDP较慢;
(6)TCP有流量控制和拥塞控制,UDP没有;
(7)TCP是重量级协议,UDP是轻量级协议;
(8)TCP首部较长20字节,UDP首部较短8字节;
(7)udp缓存扩展阅读：
TCP的可靠性原理
可靠传输有如下两个特点:
a.传输信道无差错,保证传输数据正确;
b.不管发送方以多快的速度发送数据,接收方总是来得及处理收到的数据;
（1）首先，采用三次握手来建立TCP连接，四次握手来释放TCP连接，从而保证建立的传输信道是可靠的。
（2）其次，TCP采用了连续ARQ协议（回退N，Go-back-N；超时自动重传）来保证数据传输的正确性，使用滑动窗口协议来保证接方能够及时处理所接收到的数据，进行流量控制。
（3）最后，TCP使用慢开始、拥塞避免、快重传和快恢复来进行拥塞控制，避免网络拥塞。
基于TCP和UDP的常用协议
HTTP、HTTPS、FTP、TELNET、SMTP(简单邮件传输协议)协议基于可靠的TCP协议。TFTP、DNS、DHCP、TFTP、SNMP(简单网络管理协议)、RIP基于不可靠的UDP协议
常见协议的端口号
FTP的20、21端口，21端口用来侦听用户的连接请求，而20端口用来传送用户的文件数据。
TELNET 23
SMTP25
DNS53
TFTP 69
HTTP 80
SNMP的161、162端口。SNMP的161端口用于SNMP管理进程获取SNMP代理的数据，而162端口用于SNMP代理主动向SNMP管理进程发送数据
❽ 请教Linux关于UDP最大缓冲区设置
1. tcp 收发缓冲区默认值 [root@ ]# cat /proc/sys/net/ipv4/tcp_rmem 4096 87380 4161536 87380 ：tcp接收缓冲区的默认值 [root@ ]# cat /proc/sys/net/ipv4/tcp_wmem 4096 16384 4161536 16384 ： tcp 发送缓冲区的默认值 2. tcp 或udp收发缓冲区最大值 [root@ ]# cat /proc/sys/net/core/rmem_max 131071 131071：tcp 或 udp 接收缓冲区最大可设置值的一半。 也就是说调用 setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen); 时rcv_size 如果超过 131071，那么 getsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen); 去到的值就等于 131071 * 2 = 262142 [root@ ]# cat /proc/sys/net/core/wmem_max 131071 131071：tcp 或 udp 发送缓冲区最大可设置值得一半。 跟上面同一个道理 3. udp收发缓冲区默认值 [root@ ]# cat /proc/sys/net/core/rmem_default 111616：udp接收缓冲区的默认值 [root@ ]# cat /proc/sys/net/core/wmem_default 111616 111616：udp发送缓冲区的默认值 4. tcp 或udp收发缓冲区最小值 tcp 或udp接收缓冲区的最小值为 256 bytes，由内核的宏决定； tcp 或udp发送缓冲区的最小值为 2048 bytes，由内核的宏决定
❾ ehcache rmi 的udp方式同步缓存，他的广播地址怎么确认
Ehcache缓存同步有几种方式：（1）RMI （2）Terrocotta （3）JMS （4）JGroups
先介绍下，利用RMI进行缓存同步。
测试类1：在sampleDistributedCache2缓存中查找是否存在ehcache键，如果没找到，则打印NotFound；如果找到了，则打印相应值
[java] view plain
package my.test.ehcache1;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import javax.management.MBeanServer;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.management.ManagementService;
public class EHCacheTest {
public static void main(String[] args) {
InputStream is = EHCacheTest.class
.getResourceAsStream("/my/test/ehcache1/ehcache.xml");
//读入配置
CacheManager cacheManager = new CacheManager(is);
//打印初始缓存
String[] cacheNames = cacheManager.getCacheNames();
printNames(cacheNames);
//移除缓存
cacheManager.removeCache("sampleDistributedCache1");
cacheNames = cacheManager.getCacheNames();
printNames(cacheNames);
//新建缓存
Cache cache = new Cache("Test1", 100, true, false, 10, 10);
cacheManager.addCache(cache);
cacheNames = cacheManager.getCacheNames();
printNames(cacheNames);
cache.put(new Element("test1", "value1"));
//得到缓存并插入值（这里监听器被调用）
cache = cacheManager.getCache("sampleCache3");
for (int i = 0; i < 20; i++) {
cache.put(new Element("key" + i, "value" + i));
}
cache.get("key10");
// distributed -- rmi同步
cache = cacheManager.getCache("sampleDistributedCache2");
for (int i = 0; i < 100; i++) {
cache.put(new Element("key" + i , "value" + i));
}
//注册被管理的Bean
// JMX -- jconsole(MBeanServer)
MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
ManagementService.registerMBeans(cacheManager, mBeanServer, true, true,
true, true);
for (int i = 0; i < 10; i++) {
Element temp = cache.get("ehcache");
if (temp != null) {
System.out.println(temp.getValue());
} else {
System.out.println("NotFound");
}
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// distributed cache using RMI
// 1.Peer Discovery --
// 2.CacheManager --
// 3.cache replication -- cacheEventListenerFactory
// 4.Bootstrap -- 启动后同步
}
private static void printNames(String[] names) {
System.out.println("=======================");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
}
配置文件1：将官方样例文件中相应位置替换即可
（1）其他JVM提供缓存的rmiUrl地址
[java] view plain
<
class="net.sf.ehcache.distribution."
properties="peerDiscovery=manual,
rmiUrls=//localhost:40002/sampleDistributedCache2"
propertySeparator=","
/>
（2）监听来自于其他复制节点消息的本JVM的host,port
[xhtml] view plain
<
class="net.sf.ehcache.distribution."
properties="hostName=localhost, port=40001, socketTimeoutMillis=2000"
/>
（3）配置复制选项，启动时同步等
[xhtml] view plain
<cache name="sampleDistributedCache2"
maxElementsInMemory="10"
eternal="false"
timeToIdleSeconds="100"
timeToLiveSeconds="100"
overflowToDisk="false">
<cacheEventListenerFactory
class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
properties="replicateAsynchronously=true, replicatePuts=true,
replicatePutsViaCopy=true, replicateUpdates=true,
replicateUpdatesViaCopy=true, replicateRemovals=true,
=200"/>
<bootstrapCacheLoaderFactory
class="net.sf.ehcache.distribution."/>
</cache>
测试类2：向sampleDistributedCache2缓存中添加ehcache键
[java] view plain
package my.test.ehcache2;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import javax.management.MBeanServer;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.Statistics;
import net.sf.ehcache.management.ManagementService;
import net.sf.ehcache.statistics.LiveCacheStatistics;
public class EHCacheTest {
public static void main(String[] args) {
try {
Thread.sleep(3 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//读入配置
InputStream is = EHCacheTest.class.getResourceAsStream("/my/test/ehcache2/ehcache.xml");
CacheManager cacheManager = new CacheManager(is);
//打印初始缓存
String[] cacheNames = cacheManager.getCacheNames();
printNames(cacheNames);
//注册管理Bean
MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
ManagementService.registerMBeans(cacheManager, mBeanServer, true, true, true, true);
//distributed
Cache cache = cacheManager.getCache("sampleDistributedCache2");
printCache(cache);
//添加值后另一个虚拟机的缓存通过RMI会同步缓存，并读到这个值
cache.put(new Element("ehcache", "newaddvalue"));
}
private static void printNames(String[] names) {
System.out.println("=======================");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
private static void printCache(Cache cache) {
int size = cache.getSize();
long memSize = cache.getMemoryStoreSize();
long diskSize = cache.getDiskStoreSize();
Statistics stat = cache.getStatistics();
LiveCacheStatistics liveStat = cache.getLiveCacheStatistics();
long hits = stat.getCacheHits();
long missed = stat.getCacheMisses();
long hitsOnDisk = stat.getOnDiskHits();
long liveHits = liveStat.getCacheHitCount();
long liveMissed = liveStat.getCacheMissCount();
StringBuilder sb = new StringBuilder();
sb.append("size=" + size + ";memsize=" + memSize);
sb.append(";diskSize=" + diskSize + ";hits=" + hits);
sb.append(";missed=" + missed + ";liveHits=" + liveHits);
sb.append(";liveMissed=" + liveMissed + ";hitsOnDisk=" + hitsOnDisk);
System.out.println(sb.toString());
}
}
配置文件：将官方样例文件中相应位置替换即可
[xhtml] view plain
<
class="net.sf.ehcache.distribution."
properties="peerDiscovery=manual,
rmiUrls=//localhost:40001/sampleDistributedCache2"
propertySeparator=","
/>
[xhtml] view plain
<
class="net.sf.ehcache.distribution."
properties="hostName=localhost, port=40002, socketTimeoutMillis=2000"
/>
[xhtml] view plain
<cache name="sampleDistributedCache2"
maxElementsInMemory="10"
eternal="false"
timeToIdleSeconds="100"
timeToLiveSeconds="100"
overflowToDisk="false">
<cacheEventListenerFactory
class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
properties="replicateAsynchronously=true, replicatePuts=true,
replicatePutsViaCopy=true, replicateUpdates=true,
replicateUpdatesViaCopy=true, replicateRemovals=true,
=200"/>
<bootstrapCacheLoaderFactory
class="net.sf.ehcache.distribution."/>
</cache>
❿ 如何清空udp的接收缓冲区
实际上处理这种问题时应该这样，客户端和服务端都加上自己定义的报文，在报文中加个包头包尾，这样就可以避免这个问题了，当接收到数据后，放入缓冲区，然后一个一个数据包的取出来进行分析。