先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
byte[] bytes = (byte[]) key.attachment();
key.attach(null);
System.out.println(“可写事件发生 写入消息” + Arrays.toString(bytes));
if (bytes != null) {
socketChannel.write(ByteBuffer.wrap(bytes));
}
// 写完后，就不需要写了，就切换为读事件 如果不写该行代码就会死循环
// key.interestOps(SelectionKey.OP_READ);
}
}
}
}
}
=========================================================================
- 架构图
package io.netty.example.helloworld;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.Iterator;
import java.util.Set;
/**
-
@author JavaEdge
-
@date 2021/5/17
*/
public class NioServer {
public static void main(String[] args) throws Exception {
// 创建一个ServerSocket
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8089));
// 设置为非阻塞模式
serverChannel.configureBlocking(false);
// 创建一个事件查询器
Selector selector = SelectorProvider.provider().openSelector();
// 把 ServerSocketChannel 注册到事件查询器上，并且感兴趣 OP_ACCEPT 事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
EventLoop eventLoop = new EventLoop();
while (true) {
// 阻塞方法，等待系统有I/O事件发生
int eventNum = selector.select();
System.out.println(“系统发生IO事件 数量->” + eventNum);
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
// 拿到该 key
SelectionKey key = keyIterator.next();
// 拿到后就移除它，否则后面遍历还会重复拿到它
keyIterator.remove();
// 只需处理【连接事件】 a connection was accepted by a ServerSocketChannel.
if (key.isAcceptable()) {
// 因为只有 ServerSocketChannel 有接收事件，所以可直接强转
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
// 接受客户端的连接,一个 SocketChannel 代表一个TCP连接
// 事件如果发生了，就肯定有新的连接
SocketChannel socketChannel = ssc.accept();
// 把SocketChannel设置为非阻塞模式
socketChannel.configureBlocking(false);
System.out.println("服务器接受了一个新的连接 " + socketChannel.getRemoteAddress());
// 把SocketChannel注册到Selector，并关注OP_READ事件
// socketChannel.register(selector, SelectionKey.OP_READ);
eventLoop.register(socketChannel, SelectionKey.OP_READ);
}
}
}
}
}
package io.netty.example.helloworld;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
/**
-
@author JavaEdge
-
@date 2021/5/25
*/
public class EventLoop implements Runnable {
private Selector selector;
private Thread thread;
public EventLoop() throws IOException {
this.selector = SelectorProvider.provider().openSelector();
this.thread = new Thread(this);
this.thread.start();
}
/**
- 把 channel 注册到 事件查询器
*/
public void register(SocketChannel channel, int keyOps) throws ClosedChannelException {
channel.register(selector, keyOps);
}
@Override
public void run() {
while (!Thread.interrupted()) {
try {
// 阻塞方法，等待系统有 I/0 事件产生
int eventNum = selector.select();
System.out.println(“系统发生IO事件 数量->” + eventNum);
Set keySet = selector.selectedKeys();
Iterator iterable = keySet.iterator();
while (iterable.hasNext()) {
SelectionKey key = iterable.next();
iterable.remove();
// 可读事件
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int readNum = socketChannel.read(buffer);
if (readNum == -1) {
System.out.println(“读取结束,关闭 socket”);
key.channel();
socketChannel.close();
break;
}
// 将Buffer从写模式切到读模式
buffer.flip();
byte[] bytes = new byte[readNum];
buffer.get(bytes, 0, readNum);
System.out.println(new String(bytes));
/* byte[] response = “client hello”.getBytes();
// 清理了才可以重新使用
buffer.clear();
buffer.put(response);
buffer.flip();
// 该方法非阻塞的，如果此时无法写入也不会阻塞在此，而是直接返回 0 了
socketChannel.write(buffer);
*/
// 在 key 上附加一个对象
key.attach(“EventLoop says hello to client”.getBytes());
// 把 key 关注的事件切换为写
key.interestOps(SelectionKey.OP_WRITE);
} catch (IOException e) {
System.out.println(“读取时发生异常,关闭 socket”);
// 取消 key
key.channel();
}
}
if (key.isWritable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
// 可写时再将那个对象拿出来
byte[] bytes = (byte[]) key.attachment();
key.attach(null);
System.out.println(“可写事件发生 写入消息” + Arrays.toString(bytes));
if (bytes != null) {
socketChannel.write(ByteBuffer.wrap(bytes));
}
// 写完后，就不需要写了，就切换为读事件 如果不写该行代码就会死循环
key.interestOps(SelectionKey.OP_READ);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
启动之后，开启一个客户端连接请求：
打断点到该行代码：
点击继续执行时，dump此时的线程状态：主线程已经阻塞在此
说明主线程在等待 @574线程的锁，它是谁呢？没错
EventLoop 线程阻塞在select 方法，而且它此时已经获取了Selector 内部的一把锁，所以不是Blocked状态。
但此时主线程执行 register 也需要该Selector内部的这把锁，但又不是同一线程，所以产生死锁。
所以不能由main 线程调用注册方法。
改造后的 EventLoop 类：
package io.netty.example.helloworld;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.LinkedBlockingDeque;
/**
-
@author JavaEdge
-
@date 2021/5/25
*/
public class EventLoop implements Runnable {
private Selector selector;
private Thread thread;
private Queue taskQueue = new LinkedBlockingDeque<>(32);
public EventLoop() throws IOException {
this.selector = SelectorProvider.provider().openSelector();
this.thread = new Thread(this);
this.thread.start();
}
/**
- 把 channel 注册到 事件查询器
*/
public void register(SocketChannel channel, int keyOps) {
// 将注册的逻辑封装成一个任务，因为不能让主线程执行，必须由 eventloop 的线程执行
taskQueue.add(() -> {
try {
channel.register(selector, keyOps);
} catch (ClosedChannelException e) {
e.printStackTrace();
}
});
// 但此时EventLoop的线程阻塞在 selector.select()，通过主线程唤醒它
selector.wakeup();
}
@Override
public void run() {
while (!Thread.interrupted()) {
try {
System.out.println(thread + “开始查询 I/O 事件…”);
// 阻塞方法，等待系统有 I/0 事件产生
int eventNum = selector.select();
System.out.println(“系统发生IO事件 数量->” + eventNum);
// 有事件则处理
if (eventNum > 0) {
Set keySet = selector.selectedKeys();
Iterator iterable = keySet.iterator();
while (iterable.hasNext()) {
SelectionKey key = iterable.next();
iterable.remove();
// 可读事件
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int readNum = socketChannel.read(buffer);
if (readNum == -1) {
System.out.println(“读取结束,关闭 socket”);
key.channel();
socketChannel.close();
break;
}
// 将Buffer从写模式切到读模式
buffer.flip();
byte[] bytes = new byte[readNum];
buffer.get(bytes, 0, readNum);
System.out.println(new String(bytes));
/* byte[] response = “client hello”.getBytes();
// 清理了才可以重新使用
buffer.clear();
buffer.put(response);
buffer.flip();
// 该方法非阻塞的，如果此时无法写入也不会阻塞在此，而是直接返回 0 了
socketChannel.write(buffer);
*/
// 在 key 上附加一个对象
key.attach(“EventLoop says hello to client”.getBytes());
// 把 key 关注的事件切换为写
key.interestOps(SelectionKey.OP_WRITE);
} catch (IOException e) {
System.out.println(“读取时发生异常,关闭 socket”);
// 取消 key
key.channel();
}
}
if (key.isWritable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
// 可写时再将那个对象拿出来
byte[] bytes = (byte[]) key.attachment();
key.attach(null);
System.out.println(“可写事件发生 写入消息” + Arrays.toString(bytes));
if (bytes != null) {
socketChannel.write(ByteBuffer.wrap(bytes));
}
// 写完后，就不需要写了，就切换为读事件 如果不写该行代码就会死循环
key.interestOps(SelectionKey.OP_READ);
}
}
}
// 无事件则执行任务
Runnable task;
while ((task = taskQueue.poll()) != null) {
// EventLoop执行队列中的任务，即注册任务
task.run();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
===============================================================================
由于只使用一个 Selector 来处理客户端的读写请求，如果并发太大，太多 socketchannel，这个死循环就可能处理不过来，造成大量请求超时。
所以有了EventLoopGroup。
且 channel 负责读、写事件的处理。
package io.netty.example.helloworld;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
/**
-
类似 netty 的 channel
-
@author JavaEdge
-
@date 2021/5/27
*/
public class MyChannel {
private SocketChannel channel;
private EventLoop eventLoop;
/**
- 写数据的缓冲区
*/
private Queue writeQueue = new ArrayBlockingQueue<>(16);
public MyChannel(SocketChannel channel,EventLoop eventLoop) {
this.channel = channel;
this.eventLoop = eventLoop;
}
public void read(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int readNum = socketChannel.read(buffer);
if (readNum == -1) {
System.out.println(“读取结束,关闭 socket”);
key.channel();
socketChannel.close();
return;
}
// 将Buffer从写模式切到读模式
buffer.flip();
byte[] bytes = new byte[readNum];
// 客户端发来的数据
buffer.get(bytes, 0, readNum);
String clientData = new String(bytes);
System.out.println(clientData);
// 加入写缓冲区
writeQueue.add(ByteBuffer.wrap(“hello JavaEdge”.getBytes()));
if (“flush”.equals(clientData)) {
// 把 key 关注的事件切换为写
key.interestOps(SelectionKey.OP_WRITE);
}
} catch (IOException e) {
System.out.println(“读取时发生异常,关闭 socket”);
// 取消 key
key.channel();
socketChannel.close();
}
}
public void write(SelectionKey key) throws IOException {
ByteBuffer byteBuffer;
while ((byteBuffer = writeQueue.poll()) != null) {
channel.write(byteBuffer);
}
// 写完后，就不需要写了，就切换为读事件 如果不写该行代码就会死循环
key.interestOps(SelectionKey.OP_READ);
}
}
package io.netty.example.helloworld;
import java.io.IOException;
import java.nio.channels.SocketChannel;
import java.util.concurrent.atomic.AtomicInteger;
/**
-
@author JavaEdge
-
@date 2021/5/25
*/
public class EventLoopGroup {
private EventLoop[] eventLoops = new EventLoop[2];
private final AtomicInteger idx = new AtomicInteger(0);
public EventLoop next() {
// 轮询算法
return eventLoops[idx.getAndIncrement() & eventLoops.length - 1];
}
public EventLoopGroup() throws IOException {
for (int i = 0; i < eventLoops.length; i++) {
eventLoops[i] = new EventLoop();
}
}
/**
- 其实啥也不干，直接找到一个EventLoop，丢给他干
*/
public void register(SocketChannel channel, int keyOps) {
next().register(channel, keyOps);
}
}
启动程序，客户端发起连接请求，然后点击断开连接
报错如下：
因为点击断开连接时，是会产生一个读事件请求，而这时会将该 channel 关闭
总结
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。
对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。
你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。下图涵盖了应届生乃至转行过来的小白要学习的Java内容：
请转发本文支持一下
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
启动程序，客户端发起连接请求，然后点击断开连接
报错如下：
因为点击断开连接时，是会产生一个读事件请求，而这时会将该 channel 关闭
总结
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。
对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。
你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。下图涵盖了应届生乃至转行过来的小白要学习的Java内容：
请转发本文支持一下
[外链图片转存中…(img-3h7G4Ald-1713150287923)]
[外链图片转存中…(img-kbVbfCtE-1713150287924)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-0JL6P61K-1713150287924)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
3516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
