AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java NIO 运行原理介绍

2018-09-11 915
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 开篇回想研究生期间在H3C做项目的时候第一次接触epoll的异步事件，心血来潮看了下java的NIO的实现，希望同样感兴趣的人一起看看。Netty是java NIO的集大成者，一定要看看。

开篇

回想研究生期间在H3C做项目的时候第一次接触epoll的异步事件，心血来潮看了下java的NIO的实现，希望同样感兴趣的人一起看看。Netty是java NIO的集大成者，一定要看看。


java NIO server demo

img_5e1464a920e6f040d636143c91a05f9e.png

socket server端工作标准流程

  • 创建socket： 创建ServerSocketChannel，通过ServerSocketChannel.open()方法。
  • 绑定socket：ServerSocketChannel绑定端口，通过serverSocketChannel.bind()方法。
  • 前置准备： 创建selector对象，通过Selector.open()方法。
  • 前置准备： 注册Channel到selector并绑定事件，通过serverSocketChannel.register()。
  • 监听端口号： 通过listen()方法开始进入监听。
  • 处理事件： while循环中等待select操作返回区分连接还是数据进行不同处理。
public class NIOServer {

    private Selector selector;

    public void initServer(int port) throws IOException {
        // 获得一个ServerSocketChannel通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 设置通道为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 将该通道对应的ServerSocket绑定到port端口     
        serverSocketChannel.bind(new InetSocketAddress(port));
        // 获得一个通道管理器
        this.selector = Selector.open();
        // 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
        // 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    }

    public void listen() throws IOException {
        System.out.println("服务端启动成功！");
        // 轮询访问selector
        while (true) {
            // 当注册的事件到达时，方法返回；否则,该方法会一直阻塞
            selector.select();
            // 获得selector中选中的项的迭代器，选中的项为注册的事件
            Iterator<SelectionKey> ite = this.selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();
                
                if (key.isAcceptable()) {// 客户端请求连接事件
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    // 获得和客户端连接的通道
                    SocketChannel channel = server.accept();
                    // 设置成非阻塞
                    channel.configureBlocking(false);
 
                    // 在这里可以给客户端发送信息哦
                    channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息")
                            .getBytes("utf-8")));
                    // 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
                    channel.register(this.selector, SelectionKey.OP_READ);
                    
                } else if (key.isReadable()) {// 获得了可读的事件
                    read(key);
                }
 
            }
 
        }
    }

    public void read(SelectionKey key) throws IOException {
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        // 创建读取的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(512); 
        channel.read(buffer);
        byte[] data = buffer.array();
        String msg = new String(data).trim();
        System.out.println("服务端收到信息：" + msg);
        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes("utf-8"));
        channel.write(outBuffer);// 将消息回送给客户端
    }

    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8000);
        server.listen();
    }
}


ServerSocketChannel和Selector初始化过程

 在java NIO Server的标准过程中，有两个核心的操作需要深入分析一下，分别是ServerSocketChannel.open() 和 Selector.open()两个过程，这里针对这两个对象的初始化流程进行下细致的分解。

// ServerSocketChannel的初始化过程
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

// Selector的初始化过程
selector = Selector.open();



通用逻辑抽取

  • ServerSocketChannel.open()=SelectorProvider.provider().openServerSocketChannel()
  • Selector.open()=SelectorProvider.provider().openSelector()

两者有共同点在于都调用了SelectorProvider.provider()方法，所以先把相同部分进行分析。

public abstract class ServerSocketChannel extends AbstractSelectableChannel
    implements NetworkChannel
{
    protected ServerSocketChannel(SelectorProvider provider) {
        super(provider);
    }

    public static ServerSocketChannel open() throws IOException {
        return SelectorProvider.provider().openServerSocketChannel();
    }
}


public abstract class Selector implements Closeable {

    protected Selector() { }

    public static Selector open() throws IOException {
        return SelectorProvider.provider().openSelector();
    }
}



SelectorProvider对象创建

  • SelectorProvider.provider()方法会在内部创建唯一的SelectorProvider对象，通过锁来保证创建唯一对象。
  • SelectorProvider对象通过DefaultSelectorProvider.create()方法进行创建。
  • DefaultSelectorProvider.create()方法内部根据实际系统创建不同的对象，以linux环境中EPollSelectorProvider对象为例继续分析。 
public abstract class SelectorProvider {

    private static final Object lock = new Object();
    private static SelectorProvider provider = null;

    public static SelectorProvider provider() {
        synchronized (lock) {
            if (provider != null)
                return provider;
            return AccessController.doPrivileged(
                new PrivilegedAction<SelectorProvider>() {
                    public SelectorProvider run() {
                            if (loadProviderFromProperty())
                                return provider;
                            if (loadProviderAsService())
                                return provider;
                            provider = sun.nio.ch.DefaultSelectorProvider.create();
                            return provider;
                        }
                    });
        }
    }
}



public class DefaultSelectorProvider {

    public static SelectorProvider create() {
        String osname = AccessController.doPrivileged(
            new GetPropertyAction("os.name"));
        if ("SunOS".equals(osname)) {
            return new sun.nio.ch.DevPollSelectorProvider();
        }

        // use EPollSelectorProvider for Linux kernels >= 2.6
        if ("Linux".equals(osname)) {
            String osversion = AccessController.doPrivileged(
                new GetPropertyAction("os.version"));
            String[] vers = osversion.split("\\.", 0);
            if (vers.length >= 2) {
                try {
                    int major = Integer.parseInt(vers[0]);
                    int minor = Integer.parseInt(vers[1]);
                    if (major > 2 || (major == 2 && minor >= 6)) {
                        return new sun.nio.ch.EPollSelectorProvider();
                    }
                } catch (NumberFormatException x) {
                    // format not recognized
                }
            }
        }

        return new sun.nio.ch.PollSelectorProvider();
    }
}



EPollSelectorProvider的操作过程

  • SelectorProvider.provider().openServerSocketChannel()调用EPollSelectorProvider的openServerSocketChannel()方法返回EPollSelectorImpl对象。
  • SelectorProvider.provider().openSelector()调用EPollSelectorProvider的openSelector()方法返回ServerSocketChannelImpl对象。

继续分析ServerSocketChannelImpl对象和EPollSelectorImpl对象。

public class EPollSelectorProvider extends SelectorProviderImpl
{
    public AbstractSelector openSelector() throws IOException {
        return new EPollSelectorImpl(this);
    }

    public Channel inheritedChannel() throws IOException {
        return InheritedChannel.getChannel();
    }
}



public abstract class SelectorProviderImpl extends SelectorProvider
{

    public DatagramChannel openDatagramChannel() throws IOException {
        return new DatagramChannelImpl(this);
    }

    public DatagramChannel openDatagramChannel(ProtocolFamily family) throws IOException {
        return new DatagramChannelImpl(this, family);
    }

    public Pipe openPipe() throws IOException {
        return new PipeImpl(this);
    }

    public abstract AbstractSelector openSelector() throws IOException;

    public ServerSocketChannel openServerSocketChannel() throws IOException {
        return new ServerSocketChannelImpl(this);
    }

    public SocketChannel openSocketChannel() throws IOException {
        return new SocketChannelImpl(this);
    }
}



EPollSelectorImpl对象

  • EPollSelectorImpl构造函数创建内部通信的socket对IOUtil.makePipe(false)。
  • EPollSelectorImpl的doSelect方法负责返回事件到来的fds。
  • EPollSelectorImpl的fdToKey的map保存fd和SelectionKey的映射。
class EPollSelectorImpl extends SelectorImpl
{
    // File descriptors used for interrupt
    protected int fd0;
    protected int fd1;

    // The poll object
    EPollArrayWrapper pollWrapper;

    // Maps from file descriptors to keys
    private Map<Integer,SelectionKeyImpl> fdToKey;

    // True if this Selector has been closed
    private volatile boolean closed = false;

    // Lock for interrupt triggering and clearing
    private Object interruptLock = new Object();
    private boolean interruptTriggered = false;

    EPollSelectorImpl(SelectorProvider sp) {
        super(sp);
        long pipeFds = IOUtil.makePipe(false);
        fd0 = (int) (pipeFds >>> 32);
        fd1 = (int) pipeFds;
        pollWrapper = new EPollArrayWrapper();
        pollWrapper.initInterrupt(fd0, fd1);
        fdToKey = new HashMap<Integer,SelectionKeyImpl>();
    }

    protected int doSelect(long timeout) throws IOException
    {
        if (closed)
            throw new ClosedSelectorException();
        processDeregisterQueue();
        try {
            begin();
            // 等待事件到来，收集事件到来的socket的fd并用来处理
            pollWrapper.poll(timeout);
        } finally {
            end();
        }
        processDeregisterQueue();
        // 更新需要写入的keys
        int numKeysUpdated = updateSelectedKeys();
        if (pollWrapper.interrupted()) {
            // Clear the wakeup pipe
            pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
            synchronized (interruptLock) {
                pollWrapper.clearInterrupted();
                IOUtil.drain(fd0);
                interruptTriggered = false;
            }
        }
        return numKeysUpdated;
    }

    private int updateSelectedKeys() {
        int entries = pollWrapper.updated;
        int numKeysUpdated = 0;
        for (int i=0; i<entries; i++) {
            int nextFD = pollWrapper.getDescriptor(i);
            SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
            // ski is null in the case of an interrupt
            if (ski != null) {
                int rOps = pollWrapper.getEventOps(i);
                if (selectedKeys.contains(ski)) {
                    if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
                        numKeysUpdated++;
                    }
                } else {
                    ski.channel.translateAndSetReadyOps(rOps, ski);
                    if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
                        // selectedKeys保存ski也就是事件到的socket连接
                        // ski的对象数据结构需要好好研究一下
                        selectedKeys.add(ski);
                        numKeysUpdated++;
                    }
                }
            }
        }
        return numKeysUpdated;
    }
}



ServerSocketChannelImpl对象

  • ServerSocketChannelImpl extends ServerSocketChannel
  • ServerSocketChannel extends AbstractSelectableChannel
  • ServerSocketChannelImpl对象提供bind()&accept()方法
  • ServerSocketChannelImpl的accept方法内部创建新连接的SocketChannelImpl对象返回
class ServerSocketChannelImpl extends ServerSocketChannel implements SelChImpl
{
    private final Object stateLock = new Object();
    private SocketAddress localAddress;
    ServerSocket socket;

    ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
        super(sp);
        this.fd =  Net.serverSocket(true);
        this.fdVal = IOUtil.fdVal(fd);
        this.state = ST_INUSE;
    }

    ServerSocketChannelImpl(SelectorProvider sp,
                            FileDescriptor fd,
                            boolean bound) throws IOException
    {
        super(sp);
        this.fd =  fd;
        this.fdVal = IOUtil.fdVal(fd);
        this.state = ST_INUSE;
        if (bound)
            localAddress = Net.localAddress(fd);
    }

    @Override
    public ServerSocketChannel bind(SocketAddress local, int backlog) throws IOException {
        // 省略相关代码
    }

    public SocketChannel accept() throws IOException {
       // 省略相关代码
    }

}



public abstract class AbstractSelectableChannel extends SelectableChannel
{
    protected AbstractSelectableChannel(SelectorProvider provider) {
        this.provider = provider;
    }

    public final SelectionKey register(Selector sel, int ops,
                                       Object att)
        throws ClosedChannelException
    {
        synchronized (regLock) {
            if (!isOpen())
                throw new ClosedChannelException();
            if ((ops & ~validOps()) != 0)
                throw new IllegalArgumentException();
            if (blocking)
                throw new IllegalBlockingModeException();
            SelectionKey k = findKey(sel);
            if (k != null) {
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) {
                // New registration
                synchronized (keyLock) {
                    if (!isOpen())
                        throw new ClosedChannelException();
                    k = ((AbstractSelector)sel).register(this, ops, att);
                    addKey(k);
                }
            }
            return k;
        }
    }
}


select过程

select执行过程

  • 执行selector.select()操作时实际是调用了子类实现的doSelect()方法。
  • 进一步跟进子类的doSelect()方法。
abstract class SelectorImpl extends AbstractSelector
{
    // 保存事件到来的keys
    protected Set<SelectionKey> selectedKeys;
    protected HashSet<SelectionKey> keys;
    private Set<SelectionKey> publicKeys;             // Immutable
    private Set<SelectionKey> publicSelectedKeys;     // Removal allowed, but not addition

    protected abstract int doSelect(long timeout) throws IOException;

    private int lockAndDoSelect(long timeout) throws IOException {
        synchronized (this) {
            if (!isOpen())
                throw new ClosedSelectorException();
            synchronized (publicKeys) {
                synchronized (publicSelectedKeys) {
                    return doSelect(timeout);
                }
            }
        }
    }

    public int select(long timeout) throws IOException
    {
        if (timeout < 0)
            throw new IllegalArgumentException("Negative timeout");
        return lockAndDoSelect((timeout == 0) ? -1 : timeout);
    }

    public int select() throws IOException {
        return select(0);
    }

    public Set<SelectionKey> selectedKeys() {
        if (!isOpen() && !Util.atBugLevel("1.4"))
            throw new ClosedSelectorException();
        return publicSelectedKeys;
    }
}


  • pollWrapper.poll(timeout)以超时等待的形式等待epoll的消息通知。
  • 通过updateSelectedKeys方法收集有事件到达的fds保存到selectedKeys。
class EPollSelectorImpl extends SelectorImpl
{
    protected int doSelect(long timeout) throws IOException
    {
        if (closed)
            throw new ClosedSelectorException();
        processDeregisterQueue();
        try {
            begin();
            // 等待事件到来，收集事件到来的socket的fd并用来处理
            pollWrapper.poll(timeout);
        } finally {
            end();
        }
        processDeregisterQueue();
        // 更新需要写入的keys
        int numKeysUpdated = updateSelectedKeys();
        if (pollWrapper.interrupted()) {
            // Clear the wakeup pipe
            pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
            synchronized (interruptLock) {
                pollWrapper.clearInterrupted();
                IOUtil.drain(fd0);
                interruptTriggered = false;
            }
        }
        return numKeysUpdated;
    }

    private int updateSelectedKeys() {
        int entries = pollWrapper.updated;
        int numKeysUpdated = 0;
        for (int i=0; i<entries; i++) {
            int nextFD = pollWrapper.getDescriptor(i);
            SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
            // ski is null in the case of an interrupt
            if (ski != null) {
                int rOps = pollWrapper.getEventOps(i);
                if (selectedKeys.contains(ski)) {
                    if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
                        numKeysUpdated++;
                    }
                } else {
                    ski.channel.translateAndSetReadyOps(rOps, ski);
                    if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
                        // selectedKeys保存ski也就是事件到的socket连接
                        // ski的对象数据结构需要好好研究一下
                        selectedKeys.add(ski);
                        numKeysUpdated++;
                    }
                }
            }
        }
        return numKeysUpdated;
    }
}



accept过程

  • accept的过程很简单就是accept新socket并创建SocketChannelImpl返回即可。
  • SocketChannelImpl对象后面需要注册到Selector当中所以需要进一步分析。
public SocketChannel accept() throws IOException {
            // 省略相关代码
            try {
                    // 省略相关代码
                    // 新accept的socket放在newfd当中
                    n = accept0(this.fd, newfd, isaa);
                }
            } 

            IOUtil.configureBlocking(newfd, true);
            InetSocketAddress isa = isaa[0];
            // 通过SocketChannelImpl包装newfd对象
            sc = new SocketChannelImpl(provider(), newfd, isa);
            
            // 省略相关代码
            return sc;

        }
    }



SocketChannelImpl对象

  • SocketChannelImpl可以理解为普通Socket的封装，包括read/write等方法
  • SocketChannelImpl extends SocketChannel extends AbstractSelectableChannel
  • AbstractSelectableChannel提供register到selector对象的方法
class SocketChannelImpl extends SocketChannel implements SelChImpl
{
    SocketChannelImpl(SelectorProvider sp) throws IOException {
        super(sp);
        this.fd = Net.socket(true);
        this.fdVal = IOUtil.fdVal(fd);
        this.state = ST_UNCONNECTED;
    }

    SocketChannelImpl(SelectorProvider sp,
                      FileDescriptor fd,
                      boolean bound)
        throws IOException
    {
        super(sp);
        this.fd = fd;
        this.fdVal = IOUtil.fdVal(fd);
        this.state = ST_UNCONNECTED;
        if (bound)
            this.localAddress = Net.localAddress(fd);
    }

    SocketChannelImpl(SelectorProvider sp,
                      FileDescriptor fd, InetSocketAddress remote)
        throws IOException
    {
        super(sp);
        this.fd = fd;
        this.fdVal = IOUtil.fdVal(fd);
        this.state = ST_CONNECTED;
        this.localAddress = Net.localAddress(fd);
        this.remoteAddress = remote;
    }

    public long read(ByteBuffer[] dsts, int offset, int length)
        throws IOException
    {
       // 读数据的逻辑
    }

    public int write(ByteBuffer buf) throws IOException {
     // 写数据的逻辑
    }
}



register过程

  • register过程并没有调用epollCtl方法添加fd到selector当中
  • register过程真正是保存fd到待绑定的列表当中
  • 在SelectorImpl中执行pollWrapper.poll(timeout)方法先把fd列表执行epollCtl添加selector当中，在通过epollWait获取事件到来
public abstract class AbstractSelectableChannel extends SelectableChannel
{
    public final SelectionKey register(Selector sel, int ops,
                                       Object att)
        throws ClosedChannelException
    {
        synchronized (regLock) {
            if (!isOpen())
                throw new ClosedChannelException();
            if ((ops & ~validOps()) != 0)
                throw new IllegalArgumentException();
            if (blocking)
                throw new IllegalBlockingModeException();
            SelectionKey k = findKey(sel);
            if (k != null) {
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) {
                // New registration
                synchronized (keyLock) {
                    if (!isOpen())
                        throw new ClosedChannelException();
                    k = ((AbstractSelector)sel).register(this, ops, att);
                    addKey(k);
                }
            }
            return k;
        }
    }
}

abstract class SelectorImpl extends AbstractSelector
{
    protected final SelectionKey register(AbstractSelectableChannel ch,
                                          int ops,
                                          Object attachment)
    {
        if (!(ch instanceof SelChImpl))
            throw new IllegalSelectorException();
        SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);
        k.attach(attachment);
        synchronized (publicKeys) {
            implRegister(k);
        }
        k.interestOps(ops);
        return k;
    }
}

abstract class AbstractPollSelectorImpl extends SelectorImpl
{
    protected void implRegister(SelectionKeyImpl ski) {
        synchronized (closeLock) {
            if (closed)
                throw new ClosedSelectorException();

            // Check to see if the array is large enough
            if (channelArray.length == totalChannels) {
                // Make a larger array
                int newSize = pollWrapper.totalChannels * 2;
                SelectionKeyImpl temp[] = new SelectionKeyImpl[newSize];
                // Copy over
                for (int i=channelOffset; i<totalChannels; i++)
                    temp[i] = channelArray[i];
                channelArray = temp;
                // Grow the NativeObject poll array
                pollWrapper.grow(newSize);
            }
            channelArray[totalChannels] = ski;
            ski.setIndex(totalChannels);
            // 核心的将channel添加到pollWrapper当中
            pollWrapper.addEntry(ski.channel);
            totalChannels++;
            keys.add(ski);
        }
    }
}

class EPollArrayWrapper {
    int poll(long timeout) throws IOException {
        updateRegistrations();
        updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);
        for (int i=0; i<updated; i++) {
            if (getDescriptor(i) == incomingInterruptFD) {
                interruptedIndex = i;
                interrupted = true;
                break;
            }
        }
        return updated;
    }

    void updateRegistrations() {
        synchronized (updateList) {
            Updator u = null;
            while ((u = updateList.poll()) != null) {
                SelChImpl ch = u.channel;
                if (!ch.isOpen())
                    continue;

                // if the events are 0 then file descriptor is put into "idle
                // set" to prevent it being polled
                if (u.events == 0) {
                    boolean added = idleSet.add(u.channel);
                    // if added to idle set then remove from epoll if registered
                    if (added && (u.opcode == EPOLL_CTL_MOD))
                        epollCtl(epfd, EPOLL_CTL_DEL, ch.getFDVal(), 0);
                } else {
                    // events are specified. If file descriptor was in idle set
                    // it must be re-registered (by converting opcode to ADD)
                    boolean idle = false;
                    if (!idleSet.isEmpty())
                        idle = idleSet.remove(u.channel);
                    int opcode = (idle) ? EPOLL_CTL_ADD : u.opcode;
                    epollCtl(epfd, opcode, ch.getFDVal(), u.events);
                }
            }
        }
    }
}
文章标签：
云数据库 ClickHouse
Java
Linux
关键词：
Java NIO
Java运行
Java原理
Java nio原理
NIO原理
晴天哥
目录
相关文章
flzjkl
|
5天前
|
存储 缓存 安全
【原理】【Java并发】【volatile】适合初学者体质的volatile原理
欢迎来到我的技术博客！我是一名热爱编程的开发者，梦想是写出高端的CRUD应用。2025年，我正在沉淀自己，博客更新速度也在加快。在这里，我会分享关于Java并发编程的深入理解，尤其是volatile关键字的底层原理。 本文将带你深入了解Java内存模型（JMM），解释volatile如何通过内存屏障和缓存一致性协议确保可见性和有序性，同时探讨其局限性及优化方案。欢迎订阅专栏《在2B工作中寻求并发是否搞错了什么》，一起探索并发编程的奥秘！ 关注我，点赞、收藏、评论，跟上更新节奏，让我们共同进步！
flzjkl
69 8
【原理】【Java并发】【volatile】适合初学者体质的volatile原理
运营研究坊
|
19天前
|
缓存 网络协议 Java
JAVA网络IO之NIO/BIO
本文介绍了Java网络编程的基础与历史演进，重点阐述了IO和Socket的概念。Java的IO分为设备和接口两部分，通过流、字节、字符等方式实现与外部的交互。
运营研究坊
35 0
心疼你的一切
|
1月前
|
存储 算法 Java
【JAVA】生成accessToken原理
在Java中，生成accessToken用于身份验证和授权，确保合法用户访问受保护资源。流程包括：1. 身份验证（如用户名密码、OAuth 2.0）；2. 生成唯一且安全的令牌；3. 设置令牌有效期并存储；4. 客户端传递令牌，服务器验证其有效性。常见场景为OAuth 2.0协议，涉及客户端注册、用户授权、获取授权码和换取accessToken。示例代码展示了使用Apache HttpClient库模拟OAuth 2.0获取accessToken的过程。
心疼你的一切
45 4
心疼你的一切
|
1月前
|
安全 Java 开发者
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节，提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装，以及线程池的封装。Runnable 适用于无返回值任务，Callable 支持有返回值任务。线程池（如 ExecutorService）则用于管理和复用线程，减少性能开销。示例代码展示了如何实现这些封装，使多线程编程更加高效和安全。
心疼你的一切
59 8
栈江湖
|
3月前
|
监控 Java API
探索Java NIO：究竟在哪些领域能大显身手？揭秘原理、应用场景与官方示例代码
Java NIO（New IO）自Java SE 1.4引入，提供比传统IO更高效、灵活的操作，支持非阻塞IO和选择器特性，适用于高并发、高吞吐量场景。NIO的核心概念包括通道（Channel）、缓冲区（Buffer）和选择器（Selector），能实现多路复用和异步操作。其应用场景涵盖网络通信、文件操作、进程间通信及数据库操作等。NIO的优势在于提高并发性和性能，简化编程；但学习成本较高，且与传统IO存在不兼容性。尽管如此，NIO在构建高性能框架如Netty、Mina和Jetty中仍广泛应用。
栈江湖
69 3
栈江湖
|
3月前
|
安全 算法 Java
Java CAS原理和应用场景大揭秘：你掌握了吗？
CAS（Compare and Swap）是一种乐观锁机制，通过硬件指令实现原子操作，确保多线程环境下对共享变量的安全访问。它避免了传统互斥锁的性能开销和线程阻塞问题。CAS操作包含三个步骤：获取期望值、比较当前值与期望值是否相等、若相等则更新为新值。CAS广泛应用于高并发场景，如数据库事务、分布式锁、无锁数据结构等，但需注意ABA问题。Java中常用`java.util.concurrent.atomic`包下的类支持CAS操作。
栈江湖
104 2
蓝易云
|
3月前
|
存储 监控 Java
Java的NIO体系
通过本文的介绍，希望您能够深入理解Java NIO体系的核心组件、工作原理及其在高性能应用中的实际应用，并能够在实际开发中灵活运用这些知识，构建高效的Java应用程序。
蓝易云
77 5
mikechen的互联网架构
|
4月前
|
存储 算法 Java
大厂面试高频：什么是自旋锁？Java 实现自旋锁的原理？
本文详解自旋锁的概念、优缺点、使用场景及Java实现。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
231 6
大厂面试高频：什么是自旋锁？Java 实现自旋锁的原理？
2G冲浪词条
|
4月前
|
Java
Java之CountDownLatch原理浅析
本文介绍了Java并发工具类`CountDownLatch`的使用方法、原理及其与`Thread.join()`的区别。`CountDownLatch`通过构造函数接收一个整数参数作为计数器，调用`countDown`方法减少计数，`await`方法会阻塞当前线程，直到计数为零。文章还详细解析了其内部机制，包括初始化、`countDown`和`await`方法的工作原理，并给出了一个游戏加载场景的示例代码。
2G冲浪词条
86 3
Java之CountDownLatch原理浅析
智物科技库
|
4月前
|
Java 索引 容器
Java ArrayList扩容的原理
Java 的 `ArrayList` 是基于数组实现的动态集合。初始时，`ArrayList` 底层创建一个空数组 `elementData`，并设置 `size` 为 0。当首次添加元素时，会调用 `grow` 方法将数组扩容至默认容量 10。之后每次添加元素时，如果当前数组已满，则会再次调用 `grow` 方法进行扩容。扩容规则为：首次扩容至 10，后续扩容至原数组长度的 1.5 倍或根据实际需求扩容。例如，当需要一次性添加 100 个元素时，会直接扩容至 110 而不是 15。
智物科技库
103 4
Java ArrayList扩容的原理

热门文章

最新文章

  • 1
    JAVA网络IO之NIO/BIO
  • 2
    【AI程序员】通义灵码 AI 程序员全面上线JAVA使用体验
  • 3
    接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
  • 4
    从理论到实践：使用JAVA实现RAG、Agent、微调等六种常见大模型定制策略
  • 5
    一天成为Java开发高手：用飞算JavaAI实现十倍提效
  • 6
    【Java并发】【线程池】带你从0-1入门线程池
  • 7
    Java也能快速搭建AI应用？一文带你玩转Spring AI可落地性
  • 8
    Java+机器学习基础：打造AI学习基础
  • 9
    java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
  • 10
    Java社招面试题：一个线程运行时发生异常会怎样？
  • 1
    2K star！三分钟搭建企业级后台系统，这款开源Java框架绝了！
    50
  • 2
    Java网络编程，多线程，IO流综合小项目一一ChatBoxes
    43
  • 3
    [Java计算机毕设]基于ssm的OA办公管理系统的设计与实现，附源码+数据库+论文+开题，包安装调试
    40
  • 4
    【YashanDB知识库】Java程序调用存储过程，在提取clob时报YAS-00004
    12
  • 5
    课时146：使用JDT开发Java程序
    28
  • 6
    java构造方法,构造代码块,静态代码块的执行顺序
    19
  • 7
    Java语言位运算符详解
    41
  • 8
    《从头开始学java，一天一个知识点》之：控制流程：if-else条件语句实战
    42
  • 9
    k8s的出现解决了java并发编程胡问题了
    48
  • 10
    Java方法重写（Override）与重载（Overload）的详细对比
    24

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云负载均衡SLB版本CLB、ALB和NLB有什么区别如何选择？