Linux再学！

Posted 2023-04-28 蒟蒻的小博客

第三篇Linux入门

一.linux基本指令

1.Linux根目录为/,后续路径用/分隔，如/home/admin

2.Linux命令

• 基础格式：
  
  command： 命令本身
  -options：[可选，非必填]命令的一些选项，可以通过选项控制命令的行为细节
  parameter：[可选，非必填]命令的参数，多数用于命令的指向目标等

• ls命令：
  
  ls表示展示当前目录下文件信息
  -alh为可选项
  -a：表示列出全部文件（包括隐藏文件）
  -l：以列表形式展示，并输出权限等更多信息
  -h：列出文件大小，更加便于阅读<必须搭配-l一起使用>

• cd命令
  
  切换到指定路径下<需要有执行权限>

• pwd命令
  语法就为：pwd
  查看当前所在工作目录<防迷路>

• 特殊路径符
  . 表示当前目录 cd ./Desktop
  .. 表示上一级目录, cd .. 切换到上一级目录
  ~ 表示当前用户的home目录 cd ~

• mkdir命令
  
  mkdir用于在指定路径下创建目录（文件夹）
  -p：表示自动创建不存在的父目录，适用于创建连续多层级的目录<递归创建文件>

• touch命令
  
  用于创建文件<mkdir创建文件夹>

• cat命令
  
  查看文件内容<文本格式>

• more命令
  
  cat是直接将内容全部显示出来
  more支持翻页，如果文件内容过多，可以一页页的展示
  空格进行翻页，按q即可退出查看

• cp命令
  
  可以用于复制文件\\文件夹
  参数1，Linux路径，表示被复制的文件或文件夹
  参数2，Linux路径，表示要复制去的地方
  -r用于复制文件夹，递归复制文件夹内所有文件

• mv命令
  
  用于移动文件\\文件夹（或者重命名）
  参数1，Linux路径，表示被移动的文件或文件夹
  参数2，Linux路径，表示要移动去的地方，如果目标不存在，则进行改名，确保目标存在

• rm命令
  
  用于删除文件、文件夹
  -r 选项用于删除文件夹
  -f 表示force，强制删除（不会弹出提示确认信息）
  参数可多个，表示删除多个文件
  rm -rf /*

• which命令
  
  可以通过which命令，查看所使用的一系列命令的程序文件存放在哪里

• find命令
  
  查找文件名叫做：test的文件，从根目录开始搜索： find / -name "test"<可以模糊查询>

• find可选项还有"-size"，格式如下：
  
  +、- 表示大于和小于
  n表示大小数字
  kMG表示大小单位，k(小写字母)表示kb，M表示MB，G表示GB
  从根目录下查找小于10KB的文件： find / -size -10k

• grep命令
  
  可以通过grep命令，从文件中通过关键字过滤文件行。
  选项-n，可选，表示在结果中显示匹配的行的行号。
  关键字，必填，表示过滤的关键字，带有空格或其它特殊符号，建议使用””将关键字包围起来。
  文件路径，必填，表示要过滤内容的文件路径。

*wc命令

-c，统计bytes数量 count
-m，统计字符数量 number
-l，统计行数 line
-w，统计单词数量 word count
不带可选项则全部信息输出<分别为：行数，单词数，字节数>

• 管道符|
  管道符的含义是：将管道符左边命令的结果，作为右边命令的输入
  

• echo命令
  
  可以使用echo命令在命令行内输出指定内容<类似printf>
  PS:我们可以通过将命令用反引号（通常也称之为飘号）`将其包围被该符号包围的内容，会被作为命令执行，而非普通字符
  

• 重定向符 > >>
  单个>: 将左侧命令的结果，覆盖写入到符号右侧指定的文件中
  两个>>: 将左侧命令的结果，追加写入到符号右侧指定的文件中

• tail命令
  
  可以查看文件尾部内容，跟踪文件的最新更改
  -f 表示持续跟踪文件，随时更新最后内容
  -num 表示查看尾部多少行，默认为10行(-3 -7 -5 ...)

3.vi/vim使用

• 是Linux中最经典的文本编辑器。vim为加强版
• vi\\vim编辑器的三种工作模式:
  
  命令模式（Command mode）:所敲的按键编辑器都理解为命令，以命令驱动执行不同的功能。此模型下，不能自由进行文本编辑。
  输入模式（Insert mode）:所谓的编辑模式、插入模式。此模式下，可以对文件内容进行自由编辑。
  底线命令模式（Last line mode）：通常用于文件的保存、退出。
• 通过vi/vim命令编辑文件(vim + 文件名)，会打开一个新的窗口，此时这个窗口就是：命令模式窗口,后续操作如下图切换模式。
• 命令模式快捷键
  
  
  
  常用：
  i 进入编辑模式,esc回退到命令模式.:进入底线模式
  0 光标移到当前行开头，$移动到当前行结尾
  dd 删除光标所在行 ndd<删除光标以下n行>
  yy 复制光标所在行 nyy同理
  p 粘贴 u 撤回 ctrl + r反撤回
  gg跳转到首行 G跳转到尾行

再学Netty

一、Netty简介

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

二、为什么使用Netty

2.1、手写Java NIO的缺点

因为自己写Java NIO很麻烦：
1）NIO类库和API复杂，要熟练掌握Selector, ServerSocketChannel, SocketChannel， ByteBuffer等
2）要熟悉Java多线程编程，且涉及到Reactor模式，这样才能写出高质量的NIO程序
3）臭名昭著的epoll bug，它会导致selector空轮询，最终导致CPU 100%。

2.2、Netty的优点

1）API使用简单，学习成本低
2）很多功能封装好了，如编解码、支持多种协议如PB
3）性能高：相比其他NIO框架，netty性能最优
4）社区活跃
5）Dubbo, ES，RocketMQ, GRPC等都采用了Netty，质量得到验证。

三、Netty架构图

上图为netty官网首页的架构图：
1）绿色部分是Core核心模块，包括零拷贝、API库、可扩展事件模型等
2）橙色部分：协议支持，包括http协议、webSocket、SSL、Protocol buffer, zlib/gzip压缩与解压缩，Large File Transfer大文件传输等。
3）红色部分为传输服务，包括Socket, Datagram, Http Tunnel等

从上图可以看出netty都有什么功能了：它的功能、协议、传输方式支持的都比较全。

四、Netty的使用

4.1、引入maven依赖

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.20.Final</version>
</dependency>

4.2、创建服务端启动类

public class MyServer 
    public static void main(String[] args) throws Exception 
        //创建两个线程组 boosGroup、workerGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try 
            //创建服务端的启动对象，设置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            //设置两个线程组boosGroup和workerGroup
            bootstrap.group(bossGroup, workerGroup)
                //设置服务端通道实现类型    
                .channel(NioServerSocketChannel.class)
                //设置线程队列得到连接个数    
                .option(ChannelOption.SO_BACKLOG, 128)
                //设置保持活动连接状态    
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                //使用匿名内部类的形式初始化通道对象    
                .childHandler(new ChannelInitializer<SocketChannel>() 
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception 
                            //给pipeline管道设置处理器
                            socketChannel.pipeline().addLast(new MyServerHandler());
                        
                    );//给workerGroup的EventLoop对应的管道设置处理器
            System.out.println("java技术爱好者的服务端已经准备就绪...");
            //绑定端口号，启动服务端
            ChannelFuture channelFuture = bootstrap.bind(6666).sync();
            //对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
         finally 
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        
    

4.3、创建服务端业务处理器Handler

/**
 * 自定义的Handler需要继承Netty规定好的HandlerAdapter
 * 才能被Netty框架所关联，有点类似SpringMVC的适配器模式
 **/
public class MyServerHandler extends ChannelInboundHandlerAdapter 

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception 
        //获取客户端发送过来的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("收到客户端" + ctx.channel().remoteAddress() + "发送的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
    

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception 
        //发送消息给客户端
        ctx.writeAndFlush(Unpooled.copiedBuffer("服务端已收到消息，并给你发送一个问号?", CharsetUtil.UTF_8));
    

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception 
        //发生异常，关闭通道
        ctx.close();
    

4.4、创建客户端启动类

public class MyClient 

    public static void main(String[] args) throws Exception 
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        try 
            //创建bootstrap对象，配置参数
            Bootstrap bootstrap = new Bootstrap();
            //设置线程组
            bootstrap.group(eventExecutors)
                //设置客户端的通道实现类型    
                .channel(NioSocketChannel.class)
                //使用匿名内部类初始化通道
                .handler(new ChannelInitializer<SocketChannel>() 
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception 
                            //添加客户端通道的处理器
                            ch.pipeline().addLast(new MyClientHandler());
                        
                    );
            System.out.println("客户端准备就绪，随时可以起飞~");
            //连接服务端
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666).sync();
            //对通道关闭进行监听
            channelFuture.channel().closeFuture().sync();
         finally 
            //关闭线程组
            eventExecutors.shutdownGracefully();
        
    

4.5、创建客户端业务处理器Handler

public class MyClientHandler extends ChannelInboundHandlerAdapter 

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception 
        //发送消息到服务端
        ctx.writeAndFlush(Unpooled.copiedBuffer("歪比巴卜~茉莉~Are you good~马来西亚~", CharsetUtil.UTF_8));
    

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception 
        //接收服务端发送过来的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("收到服务端" + ctx.channel().remoteAddress() + "的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
    

五、Netty的特性与重要组件

5.1、taskQueue任务队列

如果Handler处理器有一些长时间的业务处理，可以交给taskQueue异步处理，按下面的方式来通过taskQueue做业务处理：

public class MyServerHandler extends ChannelInboundHandlerAdapter 

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception 
        //获取到线程池eventLoop，添加线程，执行
        ctx.channel().eventLoop().execute(new Runnable() 
            @Override
            public void run() 
                try 
                    //长时间操作，不至于长时间的业务操作导致Handler阻塞
                    Thread.sleep(1000);
                    System.out.println("长时间的业务处理");
                 catch (Exception e) 
                    e.printStackTrace();
                
            
        );
    

总结：这就解释了上一篇reactor中的问题，在handler监听到workGroup中的事件后，实际上也放到了taskQueue线程池中做了异步处理。

5.2、scheduleTaskQueue延时任务队列

延迟任务队列，除了handler处理异步外，只是多了等一段时间在执行：

ctx.channel().eventLoop().schedule(new Runnable() 
    @Override
    public void run() 
        try 
            //长时间操作，不至于长时间的业务操作导致Handler阻塞
            Thread.sleep(1000);
            System.out.println("长时间的业务处理");
         catch (Exception e) 
            e.printStackTrace();
        
    
,5, TimeUnit.SECONDS);//5秒后执行

5.3、Future异步机制

在客户端启动时，有这样一行代码：

//连接服务端
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666).sync();

ChannelFuture提供了操作完成后，一种异步通知方式。在Socket编程中，响应结果都是阻塞的，而ChannelFuture则采用观察者模式异步返回结果：

//添加监听器
channelFuture.addListener(new ChannelFutureListener() 
    //使用匿名内部类，ChannelFutureListener接口
    //重写operationComplete方法
    @Override
    public void operationComplete(ChannelFuture future) throws Exception 
        //判断是否操作成功    
        if (future.isSuccess()) 
            System.out.println("连接成功");
         else 
            System.out.println("连接失败");
        
    
);

5.4、Bootstrap与ServerBootStrap

Bootstrap和ServerBootStrep是netty提供的创建客户端和服务端启动的工厂类，使用这个工厂类非常便利地创建启动类：

通过Bootstrap创建启动器的步骤为：

5.4.1、group()

在Reactor模式文章中，我们知道服务端要用到两个线程组：
1）bossGroup：用于监听客户端连接，专门负责与客户端创建连接，并把连接注册到WorkGroup的Selector中
2）workGroup：用于处理每一个连接发生的读写事件

一般创建线程直接使用以下new就可以了：

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

那么，既然是线程组，线程数默认多少呢？看源码：

//使用一个常量保存
private static final int DEFAULT_EVENT_LOOP_THREADS;

static 
    //NettyRuntime.availableProcessors() * 2，cpu核数的两倍赋值给常量
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

    if (logger.isDebugEnabled()) 
        logger.debug("-Dio.netty.eventLoopThreads: ", DEFAULT_EVENT_LOOP_THREADS);
    


protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) 
    //如果不传入，则使用常量的值，也就是cpu核数的两倍
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);

从源码可以看到，默认线程数是CPU核数的2倍。
如果想自定义线程数，可以使用有参构造器：

//设置bossGroup线程数为1
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
//设置workerGroup线程数为16
EventLoopGroup workerGroup = new NioEventLoopGroup(16);

5.4.2、channel()

channel() 方法用于设置通道类型，当建立连接后，会根据这个设置创建对应的Channel实例：

通道的类型有以下几种：
1）NioSocketChannel：异步非阻塞的客户端TCP Socket连接
2）NioServerSocketChannel：异步非阻塞的服务端TCP Socket连接
备注：常用的就是这两种通道类型，因为他们异步非阻塞
3）OioSocketChannel：同步阻塞的客户端TCP Socket连接
4）OioServerSocketChannel：同步阻塞的服务端TCP Socket连接

5.4.3、option() 与 childOption()

1、option() : 设置服务端用于接收进来的连接，也就是bossGroup线程
2、childOption()：是提供给父管道接收到的连接，也就是bossWork线程

SocketChannel参数，也就是childOption() 常用的参数：

SO_RCVBUF Socket参数，TCP数据接收缓冲区大小。
TCP_NODELAY TCP参数，立即发送数据，默认值为Ture。
SO_KEEPALIVE Socket参数，连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。

ServerSocketChannel参数，也就是option()参数：即boss线程池的队列长度

SO_BACKLOG Socket参数，服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝。默认值，Windows为200，其他为128。

5.4.4、设置流水线（重点）

ChannelPipeline是Netty处理请求的责任链，ChannelHander则是具体处理请求的处理器。实际上每一个channel都有一个处理器的流水线。

在Bootstrap中childHandler() 方法需要初始化通道，实例化一个ChannelInitializer，就需要重写initChannel() 初始化通道方法，装配流水线就是在这个地方进行。

代码演示如下：

//使用匿名内部类的形式初始化通道对象
bootstrap.childHandler(new ChannelInitializer<SocketChannel>() 
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception 
        //给pipeline管道设置自定义的处理器
        socketChannel.pipeline().addLast(new MyServerHandler());
    
);

处理Handler主要分为两种：
1）ChannelInboundHandlerAdapter（入栈处理器）
2）ChannelOutbountHandler （出栈处理器）

入栈指的是数据从底层java NIO Channel到Netty的Channel
出栈指的是通过Netty的Channel来操作底层的Java NIO Channel

ChannelInboundHandlerAdaptor处理器常用的事件有：
1）注册事件：fireChannelRegistered
2）连接建立事件：fireChannelActive
3）读事件和读完成事件：fireChannelRead, fireChannelReadComplete
4）异常通知事件：fireExceptionCaught
5）用户自定义事件：fireUserEventTriggered
6）Channel可写状态变化事件：fireChannelWritabilityChanged
7）连接关闭事件：fireChannelInactive

ChannelOutboundHandler处理器常用的事件由：
1）端口绑定 bind
2）连接服务器事件 connect
3）写事件 write
4）刷新时间 flush
5）读事件 read
6）主动断开连接 disconnect
7）关闭channel事件 close

5.4.5、bind()

提供用于服务端或客户端绑定服务器地址和端口号，默认是异步启动。如果加上sync() 方法则是同步。

5.4.6、优雅地关闭EventLoopGroup

//释放掉所有的资源，包括创建的线程
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();

5.5、Channel

Channel的定义：

A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind

大意是：一种连接到网络套接字或能进行读、写、连接、绑定等IO操作的组件。

Channel为用于提供：
1）通道当前的状态（例如他是否打开，是否已连接）
2）channel的配置参数（例如接收缓冲区的大小）
3）channel支持的IO操作（例如读、写、连接和绑定），以及处理与channel相关联的所有IO事件和请求的channelPipeline。

5.5.1、获取channel的状态

boolean isOpen(); //如果通道打开，则返回true
boolean isRegistered();//如果通道注册到EventLoop，则返回true
boolean isActive();//如果通道处于活动状态并且已连接，则返回true
boolean isWritable();//当且仅当I/O线程将立即执行请求的写入操作时，返回true。

5.5.2、获取channel的配置参数

获取单挑配置信息，使用getOption()：

ChannelConfig config = channel.config();//获取配置参数
//获取ChannelOption.SO_BACKLOG参数,
Integer soBackLogConfig = config.getOption(ChannelOption.SO_BACKLOG);
//因为我启动器配置的是128，所以我这里获取的soBackLogConfig=128

获取多条配置信息，用getOptions()：

ChannelConfig config = channel.config();
Map<ChannelOption<?>, Object> options = config.getOptions();
for (Map.Entry<ChannelOption<?>, Object> entry : options.entrySet()) 
    System.out.println(entry.getKey() + " : " + entry.getValue());

/**
SO_REUSEADDR : false
WRITE_BUFFER_LOW_WATER_MARK : 32768
WRITE_BUFFER_WATER_MARK : WriteBufferWaterMark(low: 32768, high: 65536)
SO_BACKLOG : 128
以下省略...
*/

5.5.3、channel支持的IO操作

1、写操作：这里演示从服务端写消息发送到客户端：

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception 
    ctx.channel().writeAndFlush(Unpooled.copiedBuffer("这波啊，这波是肉蛋葱鸡~", CharsetUtil.UTF_8));

客户端控制台：

//收到服务端/127.0.0.1:6666的消息：这波啊，这波是肉蛋葱鸡~

2、连接操作，代码演示：

ChannelFuture connect = channelFuture.channel().connect(new InetSocketAddress("127.0.0.1", 6666));//一般使用启动器，这种方式不常用

通过channel获取ChannelPipline，并做相关的处理：

//获取ChannelPipeline对象
ChannelPipeline pipeline = ctx.channel().pipeline();
//往pipeline中添加ChannelHandler处理器，装配流水线
pipeline.addLast(new MyServerHandler());

5.6、Selector

在NioEventLoop中，有一个成员变量selector, 这是nio包的Selector。

Netty中的Selector也和NIO的Selector时一样的，用于监听事件，管理注册到Selector中的channel，实现多路复用器。

5.7、Pipeline与ChannelPipeline

我们知道，可以在channel中装配ChannelHandler流水线处理器，那一个channel不可能只有一个channelHandler处理器，肯定有很多的，既然是很多channelHandler在一个流水线工作，肯定是有顺序的。

于是Pipeline就出现了，pipeline相当于处理器的容器。初始化channel时，把channelHandler按顺序装在pipeline中，就可以实现按顺序执行channelHandler了。

在一个channel中，只有一个ChannelPipeline。该pipeline在Channel被创建的时候就创建了，ChannelPipeline包含了一个ChannelHandler行成的列表，且所有ChannelHandler都会注册到ChannelPipeline中。

5.8、ChannelHandlerContext

如果想在Handler中获取pipeline对象，或者chanel对象，怎样获取呢？

Netty设计了这个ChannelHandlerContext上下文对象，就可以拿到channel、pipeline等对象，就可以进行读写等操作。

可以看到，ChannelHandlerContext是一个接口，下面有三个实现类。
实际上ChannelHandlerContext在pipeline中是一个链表的形式。看一段源码就明白了：

//ChannelPipeline实现类DefaultChannelPipeline的构造器方法
protected DefaultChannelPipeline(Channel channel) 
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel
以上是关于Linux再学！的主要内容，如果未能解决你的问题，请参考以下文章
 
 再学Linux第5章用户身份与文件权限
 会winform再学wpf简单吗
 spring再学习之AOP实操
 再学WPF自定义样式
 再学git
 再学git