关于Socket与SocketChannel的数据读写问题?

客户端读不到数据??一直处于阻塞状态...问题在服务器端还是客户端?
服务器端发送数据:

 Iterator<SocketChannel> it=clients.iterator();
                    System.out.println(clients.size());
                    while(it.hasNext()){
                        SocketChannel channel=it.next();
                        System.out.println("send message to"+channel.socket().getInetAddress()+":"+content.toString());
                        channel.write(ByteBuffer.allocate(content.length()+2).put((content.toString()+"\r\n").getBytes()));
                    }

客户端读数据:
注意:客户端是使用的Socket,服务器使用的是Channel

 public void run() {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(
                    socket.getInputStream()));
            while (!stop) {
                System.out.println(br.readLine());
                System.out.println("end");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            Resources.close(br);
        }
    }

3个回答

 服务器端的buf的write是需要循环的

还是不对,服务端用非阻塞的方式写入SocketChannel,在客户端能用socket读吗?有没有可行性?

你是对的,原来是我粗心改错了,Socket和Channel是可以相互通信的!

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
求教Java.Nio 中SocketChannel 写入数据的问题
### 请问SocketChannel 写入大一点的数据时该如何处理 ![图片说明](https://img-ask.csdn.net/upload/201901/18/1547780789_544042.png) ###这个方法如何用循环完善,不然数据稍微大点就会报错 /** * 把指定的字符串按照默认编码转化成byte字节流写入到socket channel中 * @param channel * @param buffer * @param str * @throws IOException */ public static void wirteCmd(SocketChannel channel,ByteBuffer buffer,String str) throws IOException{ buffer.clear(); byte[] bytes=str.getBytes(); buffer.put(bytes); buffer.flip(); channel.write(buffer); buffer.clear(); } ``` ```
Socketchannel写入/读取大量数据问题
我有一个客户端,一个服务端,现在要在服务端截图给客户端,每张图片大概20W字节(200KB)不到 请问socketchannel可以一次性写入这20W字节吗, 就是socketchannel.write(bytebuffer); bytebuffer的limit就是20W不到,这样写入会不会出问题 顺便问问socketchannel的write是异步的吗。。看源码怎么是一个抽象方法
SocketChannel write数据不完整的问题
我用JAVA NIO写的服务端与客户端的Socket连接程序,服务端发送信息,客户端接收信息,服务端发送信息的代码如下图:![图片说明](https://img-ask.csdn.net/upload/201904/02/1554188180_511494.jpg),遇到的问题也在图中,请问各位如何解决,先谢谢
Android Socket使用NIO的基础性问题
在尝试向SocketChannel写入数据时出问题了,每次写入后返回的Size都是0,问题代码如下: ``` SocketChannel socketChannel = null; ByteBuffer sendBuffer = null; ``` 下面这是发送数据的函数中一部分 ``` sendBuffer = ByteBuffer.wrap("hello".getBytes("UTF8")); sendBuffer.flip(); int bufferLength = sendBuffer.array().length; int sendsize = 0; while(sendBuffer.hasRemaining()) { sendsize += socketChannel.write(sendBuffer); } sendBuffer.clear(); ``` 问题1:查看了ByteBuffer.flip() 和 ByteBuffer.clear()的代码发现都是改变它的位置指针,flip是把position 和 limit 都置0,而remaining的值是limit - position,这样一来flip之后remaining不总是等于0吗?我的循环就始终没有执行,但是又在几篇帖子里看到说write之前需要先flip,于是很困惑。 问题2:如果不加while语句,不判断remaining而直接write,发现返回的size还是0,就是说没有数据被写到socketChannel里。 还请大侠指点迷津!
关于nio中的SocketChannel.read()方法原理
<div class="iteye-blog-content-contain" style="font-size: 14px;"> <p>发起请求的代码:</p> <pre name="code" class="java">SocketChannel socketChannel = SocketChannel.open(); socketChannel.connect(new InetSocketAddress("http://www.test.com", 80));</pre> <p>1)如果请求返回的数据总量是1000byte;这时这1000byte是不是已经返回到客户端了?</p> <p> </p> <p>从SocketChannel中读取数据:</p> <pre name="code" class="java">int bytesRead = socketChannel.read(buf);</pre> <p> </p> <p>2)如果buf大小是1byte,只执行一次read方法后,那剩余的999byte数据在哪里呢?</p> </div>
SocketChannel bind()地址的问题
![图片说明](https://img-ask.csdn.net/upload/201707/14/1500011273_734777.png) 上面的图片是我截取的一部分代码, 是放在while死循环里面的一段.. 因为执行起来很快,不知道循环到多少次的时候开始,每次执行到bind那里的时候,都会出现 如下的异常: ![图片说明](https://img-ask.csdn.net/upload/201707/14/1500011406_563803.png) 上网搜索了下,那个异常主要是因为端口已经被其他线程所绑定,但是, 我这里使用的是socketchannel,是作为客户端,又不是服务器,也就是说绑定的是一个远程的地址(这里使用的是本机回传地址),那么问题来了,难道一个服务器端口只能被一个客户端绑定?咋那么回事?
Socket关闭后,如何清理输出缓冲区来阻止已经在输出缓冲区中的数据发送?
实践发现,当使用socketChannel.close()之后,对于close之前已经写入缓冲区但由于网络原因没有发送成功的数据,在server端网络恢复后,还是能接收到该数据; 求问是否有什么办法能在调用Close之前,将此socketChannel的输出缓冲区中的数据清理掉? 从该博主处得到的:http://blog.csdn.net/Ctrl_qun/article/details/52454380 这些I/O缓冲区特性可整理如下: I/O缓冲区在每个TCP套接字中单独存在; I/O缓冲区在创建套接字时自动生成; 即使关闭套接字也会继续传送输出缓冲区中遗留的数据; 关闭套接字将丢失输入缓冲区中的数据。
SocketChannel发送消息
我在用SocketChannel发送消息时,当第一条消息没有接收到的时候,法第二条就会出现这个错误,请问是什么原因 java.io.IOException: 您的主机中的软件中止了一个已建立的连接。 at sun.nio.ch.SocketDispatcher.read0(Native Method) at sun.nio.ch.SocketDispatcher.read(Unknown Source) at sun.nio.ch.IOUtil.readIntoNativeBuffer(Unknown Source) at sun.nio.ch.IOUtil.read(Unknown Source) at sun.nio.ch.SocketChannelImpl.read(Unknown Source)
NIO SocketChannel连接报错
private static void testSocketChannel() throws IOException{ SocketChannel socketChannel = SocketChannel.open(); socketChannel.configureBlocking(false); socketChannel.connect(new InetSocketAddress(10086)); while(!socketChannel.finishConnect()){ System.out.println("connecting...."); try { Thread.currentThread().sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("connect success!!"); } 代码如图所以,设想是在连接成功之前,控制台会一直输出connecting....,但运行时只输出2行就报错了。。。。。
NIO中的SocketChannel多次write之后 用read如何做到区分多次的数据
例如socketChannel.write(ByteBuffer) buteBuffer的长度可能随时变更,但是接收的时候read方法是以一个固定的长度接收的 发送方 ```java byte[] outData = new byte[2048]; ByteBuffer outByteBuffer = ByteBuffer.wrap(outData); toWriteNrBytes = 获取数据返回一个长度; outByteBuffer.limit(toWriteNrBytes); socketChannel.write(outByteBuffer); ``` 接收方 ```java byte[] inData = new byte[2048]; ByteBuffer inByteBuffer = ByteBuffer.wrap(inData); readNrBytes = socketChannel.read(inByteBuffer); ``` 可是这个readNrBytes并不能实时的到每次写入的长度,请问怎么解决
关于NIO里面SocketChannel read方法 返回值问题
请问:什么情况下返回0,什么情况下返回-1. TCP/IP不太熟悉,请教各位,希望详细一点。
Android:Socket output is shutdown
``` SocketChannel socketChannel; ByteBuffer sendBuffer; //省略连接部分代码....但确保socketChannel已经和服务器socket连接上了 sendBuffer = ByteBuffer.wrap("hello".getBytes("UTF8")); socketChannel.write(sendBuffer); ``` 最后一行抛出异常java.net.SocketException: Socket output is shutdown
socket 版本问题
一个发送短信的程序 jdk从1.4 升级到1.5后发现速度明显降低 核查发现 是Socket socket = new Socket(hostname,port); 这句在 两个版本下面有明显的区别。 1.4 需要少于1s 而1.5 需要大于5s。 socket创建与建立连接虽然与网络环境有关系 但是不能在同一个环境下 两个版本相差这么多吧 有什么办法能改进一下 提高一下socket创建连接的速度 另外server 端 不允许socket创建长连接 [b]问题补充:[/b] ======================= jdk1.5里有socketchannel,可以这样: InetSocketAddress address = new InetSocketAddress(ip,port); SocketChannel channel = SocketChannel.open(address); 这样就是tcp长链接了。 ========================= 老大 1.4就已经有nio了 SocketChannel 好像在阻塞时间方面不强,所以不敢使用
java 关于NIO实现UDP数据传输问题 ,急谢谢,C币不足请不要介意
各位大侠好,小弟想问一下问题,搞了一两天没有搞明白的。因为要实现一个UDP传输服务端,于是在网上找了很多资料然后就写了一个。但是写好之后发现有两个很严重的问题,希望各位大哥给点意见或者思路去解决。 问题一:启动服务端,同时也启动客户端,客户端传输数据服务器正常接收,但是断开客户端后,再启动客户端,服务器就收不到任何客户端发送的消息,好像是服务器关闭了UDP一样,但是重启服务器后(重新打开UDP)客户端既可以发送信息过来。 问题二:多个客户端。第一个客户端连接上后,第二个客户端怎么也链接不上了。即使关闭了第一个客户端也一样。 如下是代码: package com.gateway.socket; import java.io.IOException; import java.net.InetSocketAddress; import java.net.SocketAddress; import java.net.UnknownHostException; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.util.Iterator; import java.util.Set; import org.apache.log4j.Logger; public class UDPEchoServerSelector extends Thread { private static final Logger log = Logger.getLogger(ServerSocket.class); // private InetSocketAddress inetSocketAddress; // socket处理类 private UDPSocketHandler handler = new UDPSocketHandler(); // 注册的接受服务 private SocketReceiver receiver = null; /** * 初始化socket * * @param receiver * @param hostname * @param port * @throws IOException * @throws UnknownHostException */ public UDPEchoServerSelector(SocketReceiver receiver, String hostname, int port) { if (hostname.isEmpty()) { inetSocketAddress = new InetSocketAddress(port); } else { inetSocketAddress = new InetSocketAddress(hostname, port); } this.receiver = receiver; } @Override public void run() { try { Selector selector = Selector.open(); // 创建选择器,可以处理多路通道。 DatagramChannel serverSocketChannel = DatagramChannel.open(); // 打开通道 serverSocketChannel.configureBlocking(false); // 非阻塞 serverSocketChannel.socket().bind(inetSocketAddress); /* * 将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_READ事件,注册该事件后, * 当该事件到达时,selector.select()会返回,如果该事件没到达selector.select()会一直阻塞。 */ serverSocketChannel.register(selector, SelectionKey.OP_READ, new ClientData()); log.info("Server: socket server started."); /* * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理 */ while (true) { // 轮询 // 当注册的事件到达时,方法返回;否则,该方法会一直阻塞 int nKeys = selector.select(); if (nKeys == 0) { continue; } // 得到选择键列表 Set Keys = selector.selectedKeys(); Iterator it = Keys.iterator(); while (it.hasNext()) { SelectionKey key = null; key = (SelectionKey) it.next(); // 键为位掩码 it.remove(); // 客户端请求连接事件 if (key.isValid() && key.isWritable()) { log.info("Server: SelectionKey is acceptable."); handler.handleWrite(key); } if (key.isReadable()) {// 获得了可读的事件 log.info("Server: SelectionKey is readable."); handler.receiveMsg(key, receiver); } } Keys.clear(); } } catch (IOException e) { e.printStackTrace(); } } public static class ClientData { public SocketAddress clientAddress; public ByteBuffer buffer = ByteBuffer.allocate(255); } } package com.gateway.socket; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.DatagramChannel; import java.nio.channels.SelectionKey; import org.apache.log4j.Logger; import com.gateway.common.DeviceDataTools; import com.gateway.common.data.HexUtils; import com.gateway.socket.UDPEchoServerSelector.ClientData; /** * * 处理socket类 * * @author Andy * */ public class UDPSocketHandler { private static Logger log = Logger.getLogger(UDPSocketHandler.class); /** * 链接请求 * * @throws IOException */ public void handleWrite(SelectionKey key) { try { DatagramChannel channel = (DatagramChannel) key.channel(); ClientData clntDat = (ClientData) key.attachment(); clntDat.buffer.flip(); // 从起始位置开始发送 int bytesSent; bytesSent = channel.send(clntDat.buffer, clntDat.clientAddress); if (bytesSent != 0) { key.interestOps(SelectionKey.OP_READ); // 关注客户端发送数据 } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * 读请求 * * @throws IOException */ public void receiveMsg(SelectionKey key, SocketReceiver receiver) { ByteBuffer byteBuffer = ByteBuffer.allocate(1024); byteBuffer.clear(); DatagramChannel socketChannel = (DatagramChannel) key.channel(); //非阻塞 try { socketChannel.configureBlocking(false); } catch (IOException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } System.out.println("channel code:" + socketChannel.hashCode()); try { while (true) { InetSocketAddress client = (InetSocketAddress) socketChannel .receive(byteBuffer); byteBuffer.flip(); // byteBuffer中传过来的是10进制的bytep[] byte[] dst = new byte[byteBuffer.limit()]; byteBuffer.get(dst); // 将10进制的byte[]转化成16进制字符串 String data = HexUtils.converBytesToHex(dst); System.out.println(data); log.info("Server: data1 = " + data); byteBuffer.clear(); receiver.udpreceive(socketChannel, data, client); break; } } catch (java.io.IOException e) { //e.printStackTrace(); //this.closeChannel(key, socketChannel); } catch (Exception e) { //e.printStackTrace(); //this.closeChannel(key, socketChannel); } } /** * * @param socketChannel */ private void closeChannel(SelectionKey key, DatagramChannel socketChannel) { try { while (socketChannel.isOpen()) { key.cancel(); socketChannel.close(); } } catch (IOException e1) { e1.printStackTrace(); } } /** * 根据socketKey从内存中获取channel,通过channel向client端发送消息 * * @param socketKey * 内存在channel对应的key * @param data * 发送的数据 * @return * @throws IOException */ public static boolean send(String socketKey, String data) throws IOException { DatagramChannel socketChannel = SocketChannelMapper .getUDPChannel(socketKey); if (socketChannel == null || !socketChannel.isOpen()) { return false; } InetSocketAddress client = SocketChannelMapper .getUDPInetSocketAddress(socketKey + "address"); boolean f = socketChannel.isConnected(); ByteBuffer byteBuffer = ByteBuffer.wrap(DeviceDataTools.hex2Byte(data)); if (f) { socketChannel.write(byteBuffer); } else { socketChannel.connect(new InetSocketAddress(client.getAddress(), client.getPort())); socketChannel.send(byteBuffer, client); } return true; } /** * 根据socketKey从内存中获取channel,通过channel向client端发送消息 * * @param socketKey * 内存在channel对应的key * @param data * 发送的数据 * @return * @throws IOException */ public static boolean send(DatagramChannel socketChannel, String data, InetSocketAddress client) throws IOException { if (socketChannel == null) { return false; } System.out.println("#########################ADDRESS" + client.getAddress()); System.out.println("#########################PORT" + client.getPort()); boolean f = socketChannel.isConnected(); ByteBuffer byteBuffer = ByteBuffer.wrap(DeviceDataTools.hexStr2ByteArray(data)); if (f) { socketChannel.write(byteBuffer); } else { socketChannel.connect(new InetSocketAddress(client.getAddress(), client.getPort())); socketChannel.send(byteBuffer, client); } return true; } }
Netty作为socket长链接,在windows部署占用38M左右内存,在linux部署占用1.5G左右内存
不知各位有遇到过这样问题的吗? ![图片说明](https://img-ask.csdn.net/upload/201910/19/1571456018_34605.png) 这是在linux部署直接就这样了 关于启动类我给大家粘一下代码 ``` Thread thread = new Thread(new Runnable() { @Override public void run() { //服务端要建立两个group,一个负责接收客户端的连接,一个负责处理数据传输 //连接处理group EventLoopGroup boss = new NioEventLoopGroup(); //事件处理group EventLoopGroup worker = new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); // 绑定处理group bootstrap.group(boss, worker).channel(NioServerSocketChannel.class) //保持连接数 .option(ChannelOption.SO_BACKLOG, 100000) //有数据立即发送 .option(ChannelOption.TCP_NODELAY, true) //保持连接 .childOption(ChannelOption.SO_KEEPALIVE, true) //处理新连接 .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel sc) throws Exception { // 增加任务处理 ChannelPipeline p = sc.pipeline(); p.addLast(new IdleStateHandler(new Integer(new ReadProperties().getUrlValue("read.time.seconds")),0,0)); p.addLast(new ServerIdleStateTrigger()); p.addLast(new Decoder()); p.addLast(new Encoder()); p.addLast(new ServerHandler()); } }).option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT).childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT); //绑定端口,同步等待成功 ChannelFuture future; try { future = bootstrap.bind(serverPort).sync(); if (future.isSuccess()) { serverSocketChannel = (ServerSocketChannel) future.channel(); // System.out.println("服务端开启成功"); // 启动定时删除文件的线程 new Thread(new DeleteFile()).start(); } else { // System.out.println("服务端开启失败"); } //等待服务监听端口关闭,就是由于这里会将线程阻塞,导致无法发送信息,所以我这里开了线程 future.channel().closeFuture().sync(); } catch (Exception e) { // e.printStackTrace(); } finally { //优雅地退出,释放线程池资源 boss.shutdownGracefully(); worker.shutdownGracefully(); } } }); ``` handler类继承SimpleChannelInboundHandler
关于java 实现socket的异步通信
我在网上也找到一个例子,但是没有客户端,我自己写了一个用ServerSocket连的客户端,但是连接上后不能写也不能读,不知道怎么回事,请高手解决。最好能给一个简单异步编程的例子。 下面是代码: package org.scorpion.scoket; /** * * @author chenjd */ import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.SelectableChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.charset.CharacterCodingException; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.util.HashMap; import java.util.Iterator; import java.util.Set; public class NBServer { int port = 8090; int BUFFERSIZE = 1024; Selector selector = null; ServerSocketChannel serverChannel = null; HashMap clientChannelMap = null;// 用来存放每一个客户连接对应的套接字和通道 public NBServer(int port) { this.clientChannelMap = new HashMap(); this.port = port; } public void initialize() throws IOException { // 初始化,分别实例化一个选择器,一个服务器端可选择通道 this.selector = Selector.open(); this.serverChannel = ServerSocketChannel.open(); this.serverChannel.configureBlocking(false); InetAddress localhost = InetAddress.getLocalHost(); InetSocketAddress isa = new InetSocketAddress(localhost, this.port); this.serverChannel.socket().bind(isa);// 将该套接字绑定到服务器某一可用端口 } // 结束时释放资源 public void finalize() throws IOException { this.serverChannel.close(); this.selector.close(); } // 将读入字节缓冲的信息解码 public String decode(ByteBuffer byteBuffer) throws CharacterCodingException { Charset charset = Charset.forName("ISO-8859-1"); CharsetDecoder decoder = charset.newDecoder(); CharBuffer charBuffer = decoder.decode(byteBuffer); String result = charBuffer.toString(); return result; } // 监听端口,当通道准备好时进行相应操作 public void portListening(String data) throws IOException, InterruptedException { // 服务器端通道注册OP_ACCEPT事件 SelectionKey acceptKey = this.serverChannel.register(this.selector, SelectionKey.OP_ACCEPT); // 当有已注册的事件发生时,select()返回值将大于0 while (acceptKey.selector().select() > 0) { System.out.println("event happened"); // 取得所有已经准备好的所有选择键 Set readyKeys = this.selector.selectedKeys(); // 使用迭代器对选择键进行轮询 Iterator i = readyKeys.iterator(); while (i.hasNext()) { SelectionKey key = (SelectionKey) i.next(); i.remove();// 删除当前将要处理的选择键 if (key.isAcceptable()) {// 如果是有客户端连接请求 System.out.println("more client connect in!"); ServerSocketChannel nextReady = (ServerSocketChannel) key .channel(); // 获取客户端套接字 Socket s = nextReady.accept().socket(); // 设置对应的通道为异步方式并注册感兴趣事件 s.getChannel().configureBlocking(false); SelectionKey readWriteKey = s.getChannel().register( this.selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); // 将注册的事件与该套接字联系起来 readWriteKey.attach(s); // 将当前建立连接的客户端套接字及对应的通道存放在哈希表//clientChannelMap中 this.clientChannelMap.put(s, new ClientChInstance(s .getChannel())); } else if (key.isReadable()) {// 如果是通道读准备好事件 System.out.println("Readable"); // 取得选择键对应的通道和套接字 SelectableChannel nextReady = (SelectableChannel) key .channel(); Socket socket = (Socket) key.attachment(); // 处理该事件,处理方法已封装在类ClientChInstance中 this.readFromChannel(socket.getChannel(), (ClientChInstance) this.clientChannelMap .get(socket)); } else if (key.isWritable()) {// 如果是通道写准备好事件 System.out.println("writeable"); // 取得套接字后处理,方法同上 Socket socket = (Socket) key.attachment(); SocketChannel channel = (SocketChannel) socket.getChannel(); // this.writeToChannel(channel, "This is from server!"); this.writeToChannel(channel, data); } } } } // 对通道的写操作 public void writeToChannel(SocketChannel channel, String message) throws IOException { ByteBuffer buf = ByteBuffer.wrap(message.getBytes()); int nbytes = channel.write(buf); } // 对通道的读操作 public void readFromChannel(SocketChannel channel, ClientChInstance clientInstance) throws IOException, InterruptedException { ByteBuffer byteBuffer = null; try{ byteBuffer = ByteBuffer.allocate(BUFFERSIZE); int nbytes = channel.read(byteBuffer); }catch(Exception e){ clientChannelMap.remove(channel.socket()); channel.close(); e=null; return; } byteBuffer.flip(); String result = this.decode(byteBuffer); // 当客户端发出”@exit”退出命令时,关闭其通道 if (result.indexOf("@exit") >= 0||result.indexOf("q")>=0) { channel.close(); } // else if(result.indexOf("@close") >= 0){//关闭服务 // channel.close(); // this.finalize(); // } else { clientInstance.append(result.toString()); // 读入一行完毕,执行相应操作 if (result.indexOf("\n") >= 0) { System.out.println("client input" + result); clientInstance.execute(); } } } // 该类封装了怎样对客户端的通道进行操作,具体实现可以通过重载execute()方法 public class ClientChInstance { SocketChannel channel; StringBuffer buffer = new StringBuffer(); public ClientChInstance(SocketChannel channel) { this.channel = channel; } public void execute() throws IOException { String message = "This is response after reading from channel!"; writeToChannel(this.channel, message); buffer = new StringBuffer(); } // 当一行没有结束时,将当前字窜置于缓冲尾 public void append(String values) { buffer.append(values); } } // 主程序 public static void main(String[] args) { NBServer nbServer = new NBServer(8090); try { nbServer.initialize(); } catch (Exception e) { e.printStackTrace(); System.exit(-1); } try { nbServer.portListening("This is from server!"); } catch (Exception e) { e.printStackTrace(); } } } 我写的客户端: package org.scorpion.scoket; import java.io.OutputStream; import java.net.Socket; public class TCPClient { public static void main(String[] args) throws Exception { Socket s = new Socket("172.22.71.146", 8000); OutputStream os = s.getOutputStream(); byte[] by="ksfsksjfklsdjflsdj".getBytes(); os.write(by); s.close(); } }
Java与c++进行Socket通信问题--求帮助
服务器端是C++开发的,Java开发客户端。客户端发送给服务器端的信息服务器那边可以收到,服务器也发出了响应,但是客户端一直阻塞,无法获取数据。不知道大伙能不能分享下这方面的经验。如果有样例程序更好。 在此先行谢过。 [code="java"] import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.UnsupportedEncodingException; import java.net.InetSocketAddress; import java.net.Socket; import java.net.UnknownHostException; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.channels.SocketChannel; public class WhyNotWork { /** * @param args * @throws IOException * @throws UnknownHostException * @throws IOException */ public static void main(String[] args) throws UnknownHostException { String sendString = Header.get() + "hello "; Socket socket = null; try { socket = new Socket("192.168.10.3", 5555); } catch (IOException e) { e.printStackTrace(); } if (socket.isConnected()) { System.out.println("is connected"); } else { return; } PrintWriter writer = null; BufferedReader reader = null; try { writer = new PrintWriter(socket.getOutputStream()); reader = new BufferedReader(new InputStreamReader(socket .getInputStream())); writer.println(sendString.getBytes()); writer.flush(); char[] buffer = new char[1024]; while (reader.read(buffer) != -1) { System.out.println(new String(buffer)); } } catch (IOException e) { e.printStackTrace(); } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { e.printStackTrace(); } } if (writer != null) { writer.close(); } if (socket != null) { try { socket.close(); } catch (IOException e) { e.printStackTrace(); } } } } } [/code]
java nio的select和linux的epoll有什么区别?
#### 最近在看关于epoll和select相关问题,但是并没有发现java的select和linux的epoll有什么区别 #### java的nio select代码如下 ``` import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.charset.Charset; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.UUID; public class NioServer { private static Map<String, SocketChannel> clientMap = new HashMap<>(); public static void main(String[] args) throws IOException { ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.configureBlocking(false); ServerSocket serverSocket = serverSocketChannel.socket(); serverSocket.bind(new InetSocketAddress(8899)); Selector selector = Selector.open(); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { try { /** * 程序会卡在select()函数,当客户端有动作了,比如连接上了,或者是发送消息过来了,服务端才会继续走 * 当第一个客户端连接上并且是selectionKey.isAcceptable(),代码就又重新卡到了select()函数上 * 等待客户端的再次操作(无论是哪个客户端) */ selector.select(); /** * selector.selectedKeys()这段代码可以从中知道是哪个客户端,执行了什么操作 * */ Set<SelectionKey> selectionKeys = selector.selectedKeys(); selectionKeys.forEach((selectionKey) -> { final SocketChannel client; try { if (selectionKey.isAcceptable()) { ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel(); /** * 这代代码获取了真正的客户端socket句柄 */ client = server.accept(); client.configureBlocking(false); /** * 这句话如果不写,就相当于没有注册当消息可读时的回调函数,当客户端发送消息过来的时候 * 服务端的selector.selectedKeys()就永远不会受到这类消息 */ client.register(selector, SelectionKey.OP_READ); String key = "[" + UUID.randomUUID().toString() + "]"; clientMap.put(key, client); } else if (selectionKey.isReadable()) { client = (SocketChannel) selectionKey.channel(); ByteBuffer readBuffer = ByteBuffer.allocate(1024); int count = client.read(readBuffer); if (count > 0) { readBuffer.flip(); Charset charset = Charset.forName("utf-8"); String recvMsg = String.valueOf(charset.decode(readBuffer).array()); System.out.println(client + ":" + recvMsg); String sendKey = null; for (Map.Entry<String, SocketChannel> stringSocketChannelEntry : clientMap.entrySet()) { if (stringSocketChannelEntry.getValue() == client) { sendKey = stringSocketChannelEntry.getKey(); break; } } for (Map.Entry<String, SocketChannel> stringSocketChannelEntry : clientMap.entrySet()) { SocketChannel socketChannel = stringSocketChannelEntry.getValue(); ByteBuffer writeBuffer = ByteBuffer.allocate(1024); writeBuffer.put((sendKey + ": " + recvMsg).getBytes()); writeBuffer.flip(); socketChannel.write(writeBuffer); } } } } catch (Exception ex) { ex.printStackTrace(); } }); selectionKeys.clear(); } catch (Exception e) { e.printStackTrace(); } } } } ``` #### linux的epoll的c代码如下 ``` #include <iostream> #include <sys/socket.h> #include <sys/epoll.h> #include <netinet/in.h> #include <arpa/inet.h> #include <fcntl.h> #include <unistd.h> #include <stdio.h> #include <errno.h> #include <cstring> using namespace std; #define MAXLINE 5 #define OPEN_MAX 100 #define LISTENQ 20 #define SERV_PORT 5000 #define INFTIM 1000 void setnonblocking(int sock) { int opts; opts=fcntl(sock,F_GETFL); if(opts<0) { perror("fcntl(sock,GETFL)"); exit(1); } opts = opts|O_NONBLOCK; if(fcntl(sock,F_SETFL,opts)<0) { perror("fcntl(sock,SETFL,opts)"); exit(1); } } int main(int argc, char* argv[]) { int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber; ssize_t n; char line[MAXLINE]; socklen_t clilen; if ( 2 == argc ) { if( (portnumber = atoi(argv[1])) < 0 ) { fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]); return 1; } } else { fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]); return 1; } //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件 struct epoll_event ev,events[20]; //生成用于处理accept的epoll专用的文件描述符 //创建一个epoll文件描述符 epfd=epoll_create(256); struct sockaddr_in clientaddr; struct sockaddr_in serveraddr; listenfd = socket(AF_INET, SOCK_STREAM, 0); //把socket设置为非阻塞方式 //setnonblocking(listenfd); //设置与要处理的事件相关的文件描述符 ev.data.fd=listenfd; //设置要处理的事件类型 ev.events=EPOLLIN|EPOLLET; //ev.events=EPOLLIN; //注册epoll事件,将socket文件描述符listenfd的ev事件注册到epoll上 epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); memset(&serveraddr, sizeof(serveraddr) ,0); serveraddr.sin_family = AF_INET; char *local_addr="127.0.0.1"; inet_aton(local_addr,&(serveraddr.sin_addr));//htons(portnumber); serveraddr.sin_port=htons(portnumber); //先bind再监听 bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr)); listen(listenfd, LISTENQ); maxi = 0; for ( ; ; ) { //等待epoll事件的发生 //param epfd表示将监听epfd的事件 //param events表示容器,一旦有事件发生,events数组会被填充 nfds=epoll_wait(epfd,events,20,500); //处理所发生的所有事件 for(i=0;i<nfds;++i) { if(events[i].data.fd==listenfd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口,建立新的连接。 { connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen); if(connfd<0){ perror("connfd<0"); exit(1); } //setnonblocking(connfd); char *str = inet_ntoa(clientaddr.sin_addr); cout << "accapt a connection from " << str << endl; //设置用于读操作的文件描述符 ev.data.fd=connfd; //设置用于注测的读操作事件 ev.events=EPOLLIN|EPOLLET; //ev.events=EPOLLIN; //注册ev epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); } else if(events[i].events&EPOLLIN)//如果是已经连接的用户,并且收到数据,那么进行读入。 { cout << "EPOLLIN" << endl; if ( (sockfd = events[i].data.fd) < 0) continue; if ( (n = read(sockfd, line, MAXLINE)) < 0) { if (errno == ECONNRESET) { close(sockfd); events[i].data.fd = -1; } else std::cout<<"readline error"<<std::endl; } else if (n == 0) { close(sockfd); events[i].data.fd = -1; } line[n] = '/0'; cout << "read " << line << endl; //设置用于写操作的文件描述符 ev.data.fd=sockfd; //设置用于注测的写操作事件 ev.events=EPOLLOUT|EPOLLET; //修改sockfd上要处理的事件为EPOLLOUT //epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); } else if(events[i].events&EPOLLOUT) // 如果有数据发送 { sockfd = events[i].data.fd; write(sockfd, line, n); //设置用于读操作的文件描述符 ev.data.fd=sockfd; //设置用于注测的读操作事件 ev.events=EPOLLIN|EPOLLET; //修改sockfd上要处理的事件为EPOLIN epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); } } } return 0; } ``` #### 从上面两段代码看好像基本思想都是一样的,并没有传说中的select不知道发生的事件,只能通过循环去判断的情况。 #### 但是后来我又在网上找了一段linux的select实现的网络io代码 ``` #include<stdio.h> #include<sys/types.h> #include<sys/socket.h> #include<unistd.h> #include<stdlib.h> #include<errno.h> #include<arpa/inet.h> #include<netinet/in.h> #include<string.h> #include<signal.h> #define MAXLINE 1024 #define LISTENLEN 10 #define SERV_PORT 6666 int main(int argc, char **argv) { int i, maxi, maxfd, listenfd, connfd, sockfd; int nready, client[FD_SETSIZE]; ssize_t n; fd_set rset, allset; char buf[MAXLINE]; socklen_t clilen; struct sockaddr_in cliaddr, servaddr; listenfd = socket(AF_INET, SOCK_STREAM, 0); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(SERV_PORT); bind(listenfd, (struct sockaddr*) &servaddr, sizeof(servaddr)); listen(listenfd, LISTENLEN); maxfd = listenfd; /* initialize */ maxi = -1; /* index into client[] array */ for (i = 0; i < FD_SETSIZE; i++) client[i] = -1; /* -1 indicates available entry */ FD_ZERO(&allset); FD_SET(listenfd, &allset); for ( ; ; ) { rset = allset; /* structure assignment */ nready = select(maxfd+1, &rset, NULL, NULL, NULL); if (FD_ISSET(listenfd, &rset)) /* new client connection */ { clilen = sizeof(cliaddr); connfd = accept(listenfd, (struct sockaddr*) &cliaddr, &clilen); #ifdef NOTDEF printf("new client: %s, port %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL), ntohs(cliaddr.sin_port)); #endif for (i = 0; i < FD_SETSIZE; i++) if (client[i] < 0) { client[i] = connfd; /* save descriptor */ break; } if (i == FD_SETSIZE) { printf("too many clients"); exit(0); } FD_SET(connfd, &allset); /* add new descriptor to set */ if (connfd > maxfd) maxfd = connfd; /* for select */ if (i > maxi) maxi = i; /* max index in client[] array */ if (--nready <= 0) continue; /* no more readable descriptors */ } for (i = 0; i <= maxi; i++) /* check all clients for data */ { if ( (sockfd = client[i]) < 0) continue; if (FD_ISSET(sockfd, &rset)) { if ( (n = read(sockfd, buf, MAXLINE)) == 0)/* connection closed by client */ { close(sockfd); FD_CLR(sockfd, &allset); client[i] = -1; } else write(sockfd, buf, n); if (--nready <= 0) break; /* no more readable descriptors */ } } } } ``` #### 从这段代码里面确实是可以看出是通过循环判断的,我的问题是java的select是不是就是linux的epoll的思想?
Java NIO read阻塞问题(急需解决!,高手素来!!)
我做的是服务端Socket,各位高手先看看代码吧 ServerSocketChannel serverChannel = ServerSocketChannel.open(); serverChannel.socket().bind(new InetSocketAddress(CommonBean.getSocketPort())); serverChannel.configureBlocking(false); Selector acceptSelector = SelectorProvider.provider().openSelector(); SelectionKey acceptKey = serverChannel.register(acceptSelector, SelectionKey.OP_ACCEPT); int keysAdded = 0; int k = 0; while ((keysAdded = acceptSelector.select(1000 * 60)) > 0) { Set readyKeys = acceptSelector.selectedKeys(); Iterator i = readyKeys.iterator(); while (i.hasNext()) { SelectionKey selectionkey = (SelectionKey) i.next(); i.remove(); if (selectionkey != null) { new Thread(new SocketThread(selectionkey)).start(); } } } ======================================================== public class SocketThread extends Thread { public SocketThread(SelectionKey selectionkey) { this.selectionkey = selectionkey; } public void run() { try { ServerSocketChannel nextReady = (ServerSocketChannel) selectionkey.channel(); socketChannel = nextReady.accept(); if (socketChannel != null){ socketLog.info("[ "+socketChannel.socket().getInetAddress().getHostAddress()+" ] Thread started...."); processRequest(); socketLog.info("[ "+socketChannel.socket().getInetAddress().getHostAddress()+" ] Thread ended..."); } } catch (Exception e) { socketLog.error(e.getMessage(), e); } } private void processRequest() { try { while (true) { ByteBuffer tempMsgID = ByteBuffer.allocate(4); tempMsgID.clear(); socketChannel.read(tempMsgID); tempMsgID.flip(); if (tempMsgID.limit() == 0) { break; } } } catch (IOException e) { e.printStackTrace(); }finally { try { socketChannel.socket().close(); } catch (IOException e) { e.printStackTrace(); } } } } 我把服务端建立socket通讯的主要代码都摘取出来了,麻烦各位高手分析一下问题的原因以及解决的办法,我的问题如下: 一、我在前面已经设置了serverChannel.configureBlocking(false);为非阻塞模式,为什么当我调用socketChannel.read(tempMsgID);的时候,read依然用阻塞的方式去读取数据呢? 二、测试时候发现,如果客户端拔网线或者拔电源时,服务端不知道客户端退出,所以read就永远死在程序里了,当前的这个线程就一直存在了,我现在想设置read的timeout,比如说不管客户端异常退出还是由于其他原因,只要read超过3分钟,我就将当前这个socket关闭退出,在网上找了好久,没找到如何能设置socketChannel的timeout方法,不知道是我没找到,socketChannel就无法设置超时,如果无法设置超时,那么我的这个问题有没有别的解决办法呢? 三、我在网上查找socketChannel的timeout的方法时,发现socket可以设置超时,所以想到将socket从socketChannel中提取出来,用socket的方式进行读取,例如:socketChannel.socket().getinputstream();虽然说新版的NIO和旧版的纯socket相结合使用有点不伦不类,但是数据真的能正常收取,并且设置timeout也按时退出了,但是这种方式有新的问题,当我用20台客户端并发访问服务端的时候,运行一段时间就报too many open files的错误了,我检查程序了,我在最后的finally模块中,确实每次都将inputstream和socket全都close()了,但是依然解决不了too many open files异常,不知道该怎么办了。 希望NIO方面的高手来指点一下,NIO我接触的不多,现在这几个问题实在是没有能力解决了。
终于明白阿里百度这样的大公司,为什么面试经常拿ThreadLocal考验求职者了
点击上面↑「爱开发」关注我们每晚10点,捕获技术思考和创业资源洞察什么是ThreadLocalThreadLocal是一个本地线程副本变量工具类,各个线程都拥有一份线程私...
《奇巧淫技》系列-python!!每天早上八点自动发送天气预报邮件到QQ邮箱
将代码部署服务器,每日早上定时获取到天气数据,并发送到邮箱。 也可以说是一个小人工智障。 思路可以运用在不同地方,主要介绍的是思路。
面试官问我:什么是消息队列?什么场景需要他?用了会出现什么问题?
你知道的越多,你不知道的越多 点赞再看,养成习惯 GitHub上已经开源 https://github.com/JavaFamily 有一线大厂面试点脑图、个人联系方式和人才交流群,欢迎Star和完善 前言 消息队列在互联网技术存储方面使用如此广泛,几乎所有的后端技术面试官都要在消息队列的使用和原理方面对小伙伴们进行360°的刁难。 作为一个在互联网公司面一次拿一次Offer的面霸...
8年经验面试官详解 Java 面试秘诀
作者 |胡书敏 责编 | 刘静 出品 | CSDN(ID:CSDNnews) 本人目前在一家知名外企担任架构师,而且最近八年来,在多家外企和互联网公司担任Java技术面试官,前后累计面试了有两三百位候选人。在本文里,就将结合本人的面试经验,针对Java初学者、Java初级开发和Java开发,给出若干准备简历和准备面试的建议。 Java程序员准备和投递简历的实...
究竟你适不适合买Mac?
我清晰的记得,刚买的macbook pro回到家,开机后第一件事情,就是上了淘宝网,花了500元钱,找了一个上门维修电脑的师傅,上门给我装了一个windows系统。。。。。。 表砍我。。。 当时买mac的初衷,只是想要个固态硬盘的笔记本,用来运行一些复杂的扑克软件。而看了当时所有的SSD笔记本后,最终决定,还是买个好(xiong)看(da)的。 已经有好几个朋友问我mba怎么样了,所以今天尽量客观...
MyBatis研习录(01)——MyBatis概述与入门
MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis原本是apache的一个开源项目iBatis, 2010年该项目由apache software foundation 迁移到了google code并改名为MyBatis 。2013年11月MyBatis又迁移到Github。
程序员一般通过什么途径接私活?
二哥,你好,我想知道一般程序猿都如何接私活,我也想接,能告诉我一些方法吗? 上面是一个读者“烦不烦”问我的一个问题。其实不止是“烦不烦”,还有很多读者问过我类似这样的问题。 我接的私活不算多,挣到的钱也没有多少,加起来不到 20W。说实话,这个数目说出来我是有点心虚的,毕竟太少了,大家轻喷。但我想,恰好配得上“一般程序员”这个称号啊。毕竟苍蝇再小也是肉,我也算是有经验的人了。 唾弃接私活、做外...
Python爬虫爬取淘宝,京东商品信息
小编是一个理科生,不善长说一些废话。简单介绍下原理然后直接上代码。 使用的工具(Python+pycharm2019.3+selenium+xpath+chromedriver)其中要使用pycharm也可以私聊我selenium是一个框架可以通过pip下载 pip installselenium -ihttps://pypi.tuna.tsinghua.edu.cn/simple/ ...
阿里程序员写了一个新手都写不出的低级bug,被骂惨了。
这种新手都不会范的错,居然被一个工作好几年的小伙子写出来,差点被当场开除了。
Java工作4年来应聘要16K最后没要,细节如下。。。
前奏: 今天2B哥和大家分享一位前几天面试的一位应聘者,工作4年26岁,统招本科。 以下就是他的简历和面试情况。 基本情况: 专业技能: 1、&nbsp;熟悉Sping了解SpringMVC、SpringBoot、Mybatis等框架、了解SpringCloud微服务 2、&nbsp;熟悉常用项目管理工具:SVN、GIT、MAVEN、Jenkins 3、&nbsp;熟悉Nginx、tomca...
Python爬虫精简步骤1 获取数据
爬虫,从本质上来说,就是利用程序在网上拿到对我们有价值的数据。 爬虫能做很多事,能做商业分析,也能做生活助手,比如:分析北京近两年二手房成交均价是多少?广州的Python工程师平均薪资是多少?北京哪家餐厅粤菜最好吃?等等。 这是个人利用爬虫所做到的事情,而公司,同样可以利用爬虫来实现巨大的商业价值。比如你所熟悉的搜索引擎——百度和谷歌,它们的核心技术之一也是爬虫,而且是超级爬虫。 从搜索巨头到人工...
Python绘图,圣诞树,花,爱心 | Turtle篇
每周每日,分享Python实战代码,入门资料,进阶资料,基础语法,爬虫,数据分析,web网站,机器学习,深度学习等等。 公众号回复【进群】沟通交流吧,QQ扫码进群学习吧 微信群 QQ群 1.画圣诞树 import turtle screen = turtle.Screen() screen.setup(800,600) circle = turtle.Turtle()...
作为一个程序员,CPU的这些硬核知识你必须会!
CPU对每个程序员来说,是个既熟悉又陌生的东西? 如果你只知道CPU是中央处理器的话,那可能对你并没有什么用,那么作为程序员的我们,必须要搞懂的就是CPU这家伙是如何运行的,尤其要搞懂它里面的寄存器是怎么一回事,因为这将让你从底层明白程序的运行机制。 随我一起,来好好认识下CPU这货吧 把CPU掰开来看 对于CPU来说,我们首先就要搞明白它是怎么回事,也就是它的内部构造,当然,CPU那么牛的一个东...
破14亿,Python分析我国存在哪些人口危机!
一、背景 二、爬取数据 三、数据分析 1、总人口 2、男女人口比例 3、人口城镇化 4、人口增长率 5、人口老化(抚养比) 6、各省人口 7、世界人口 四、遇到的问题 遇到的问题 1、数据分页,需要获取从1949-2018年数据,观察到有近20年参数:LAST20,由此推测获取近70年的参数可设置为:LAST70 2、2019年数据没有放上去,可以手动添加上去 3、将数据进行 行列转换 4、列名...
web前端javascript+jquery知识点总结
1.Javascript 语法.用途 javascript 在前端网页中占有非常重要的地位,可以用于验证表单,制作特效等功能,它是一种描述语言,也是一种基于对象(Object)和事件驱动并具有安全性的脚本语言 ...
Python实战:抓肺炎疫情实时数据,画2019-nCoV疫情地图
今天,群里白垩老师问如何用python画武汉肺炎疫情地图。白垩老师是研究海洋生态与地球生物的学者,国家重点实验室成员,于不惑之年学习python,实为我等学习楷模。先前我并没有关注武汉肺炎的具体数据,也没有画过类似的数据分布图。于是就拿了两个小时,专门研究了一下,遂成此文。
听说想当黑客的都玩过这个Monyer游戏(1~14攻略)
第零关 进入传送门开始第0关(游戏链接) 请点击链接进入第1关: 连接在左边→ ←连接在右边 看不到啊。。。。(只能看到一堆大佬做完的留名,也能看到菜鸡的我,在后面~~) 直接fn+f12吧 &lt;span&gt;连接在左边→&lt;/span&gt; &lt;a href="first.php"&gt;&lt;/a&gt; &lt;span&gt;←连接在右边&lt;/span&gt; o...
在家远程办公效率低?那你一定要收好这个「在家办公」神器!
相信大家都已经收到国务院延长春节假期的消息,接下来,在家远程办公可能将会持续一段时间。 但是问题来了。远程办公不是人在电脑前就当坐班了,相反,对于沟通效率,文件协作,以及信息安全都有着极高的要求。有着非常多的挑战,比如: 1在异地互相不见面的会议上,如何提高沟通效率? 2文件之间的来往反馈如何做到及时性?如何保证信息安全? 3如何规划安排每天工作,以及如何进行成果验收? ...... ...
作为一个程序员,内存和磁盘的这些事情,你不得不知道啊!!!
截止目前,我已经分享了如下几篇文章: 一个程序在计算机中是如何运行的?超级干货!!! 作为一个程序员,CPU的这些硬核知识你必须会! 作为一个程序员,内存的这些硬核知识你必须懂! 这些知识可以说是我们之前都不太重视的基础知识,可能大家在上大学的时候都学习过了,但是嘞,当时由于老师讲解的没那么有趣,又加上这些知识本身就比较枯燥,所以嘞,大家当初几乎等于没学。 再说啦,学习这些,也看不出来有什么用啊!...
渗透测试-灰鸽子远控木马
木马概述 灰鸽子( Huigezi),原本该软件适用于公司和家庭管理,其功能十分强大,不但能监视摄像头、键盘记录、监控桌面、文件操作等。还提供了黑客专用功能,如:伪装系统图标、随意更换启动项名称和表述、随意更换端口、运行后自删除、毫无提示安装等,并采用反弹链接这种缺陷设计,使得使用者拥有最高权限,一经破解即无法控制。最终导致被黑客恶意使用。原作者的灰鸽子被定义为是一款集多种控制方式于一体的木马程序...
Python:爬取疫情每日数据
前言 目前每天各大平台,如腾讯、今日头条都会更新疫情每日数据,他们的数据源都是一样的,主要都是通过各地的卫健委官网通报。 以全国、湖北和上海为例,分别为以下三个网站: 国家卫健委官网:http://www.nhc.gov.cn/xcs/yqtb/list_gzbd.shtml 湖北卫健委官网:http://wjw.hubei.gov.cn/bmdt/ztzl/fkxxgzbdgrfyyq/xxfb...
这个世界上人真的分三六九等,你信吗?
偶然间,在知乎上看到一个问题 一时间,勾起了我深深的回忆。 以前在厂里打过两次工,做过家教,干过辅导班,做过中介。零下几度的晚上,贴过广告,满脸、满手地长冻疮。 再回首那段岁月,虽然苦,但让我学会了坚持和忍耐。让我明白了,在这个世界上,无论环境多么的恶劣,只要心存希望,星星之火,亦可燎原。 下文是原回答,希望能对你能有所启发。 如果我说,这个世界上人真的分三六九等,...
B 站上有哪些很好的学习资源?
哇说起B站,在小九眼里就是宝藏般的存在,放年假宅在家时一天刷6、7个小时不在话下,更别提今年的跨年晚会,我简直是跪着看完的!! 最早大家聚在在B站是为了追番,再后来我在上面刷欧美新歌和漂亮小姐姐的舞蹈视频,最近两年我和周围的朋友们已经把B站当作学习教室了,而且学习成本还免费,真是个励志的好平台ヽ(.◕ฺˇд ˇ◕ฺ;)ノ 下面我们就来盘点一下B站上优质的学习资源: 综合类 Oeasy: 综合...
雷火神山直播超两亿,Web播放器事件监听是怎么实现的?
Web播放器解决了在手机浏览器和PC浏览器上播放音视频数据的问题,让视音频内容可以不依赖用户安装App,就能进行播放以及在社交平台进行传播。在视频业务大数据平台中,播放数据的统计分析非常重要,所以Web播放器在使用过程中,需要对其内部的数据进行收集并上报至服务端,此时,就需要对发生在其内部的一些播放行为进行事件监听。 那么Web播放器事件监听是怎么实现的呢? 01 监听事件明细表 名...
3万字总结,Mysql优化之精髓
本文知识点较多,篇幅较长,请耐心学习 MySQL已经成为时下关系型数据库产品的中坚力量,备受互联网大厂的青睐,出门面试想进BAT,想拿高工资,不会点MySQL优化知识,拿offer的成功率会大大下降。 为什么要优化 系统的吞吐量瓶颈往往出现在数据库的访问速度上 随着应用程序的运行,数据库的中的数据会越来越多,处理时间会相应变慢 数据是存放在磁盘上的,读写速度无法和内存相比 如何优化 设计...
Python新型冠状病毒疫情数据自动爬取+统计+发送报告+数据屏幕(三)发送篇
今天介绍的项目是使用 Itchat 发送统计报告 项目功能设计: 定时爬取疫情数据存入Mysql 进行数据分析制作疫情报告 使用itchat给亲人朋友发送分析报告 基于Django做数据屏幕 使用Tableau做数据分析 来看看最终效果 目前已经完成,预计2月12日前更新 使用 itchat 发送数据统计报告 itchat 是一个基于 web微信的一个框架,但微信官方并不允许使用这...
作为程序员的我,大学四年一直自学,全靠这些实用工具和学习网站!
我本人因为高中沉迷于爱情,导致学业荒废,后来高考,毫无疑问进入了一所普普通通的大学,实在惭愧???? 我又是那么好强,现在学历不行,没办法改变的事情了,所以,进入大学开始,我就下定决心,一定要让自己掌握更多的技能,尤其选择了计算机这个行业,一定要多学习技术。 在进入大学学习不久后,我就认清了一个现实:我这个大学的整体教学质量和学习风气,真的一言难尽,懂的人自然知道怎么回事? 怎么办?我该如何更好的提升自...
粒子群算法求解物流配送路线问题(python)
1.Matlab实现粒子群算法的程序代码:https://www.cnblogs.com/kexinxin/p/9858664.html matlab代码求解函数最优值:https://blog.csdn.net/zyqblog/article/details/80829043 讲解通俗易懂,有数学实例的博文:https://blog.csdn.net/daaikuaichuan/article/...
教你如何编写第一个简单的爬虫
很多人知道爬虫,也很想利用爬虫去爬取自己想要的数据,那么爬虫到底怎么用呢?今天就教大家编写一个简单的爬虫。 下面以爬取笔者的个人博客网站为例获取第一篇文章的标题名称,教大家学会一个简单的爬虫。 第一步:获取页面 #!/usr/bin/python # coding: utf-8 import requests #引入包requests link = "http://www.santostang....
前端JS初级面试题二 (。•ˇ‸ˇ•。)老铁们!快来瞧瞧自己都会了么
1. 传统事件绑定和符合W3C标准的事件绑定有什么区别? 传统事件绑定 &lt;div onclick=""&gt;123&lt;/div&gt; div1.onclick = function(){}; &lt;button onmouseover=""&gt;&lt;/button&gt; 注意: 如果给同一个元素绑定了两次或多次相同类型的事件,那么后面的绑定会覆盖前面的绑定 (不支持DOM事...
相关热词 c#如何定义数组列表 c#倒序读取txt文件 java代码生成c# c# tcp发送数据 c#解决时间格式带星期 c#类似hashmap c#设置istbox的值 c#获取多线程返回值 c# 包含数字 枚举 c# timespan
立即提问