iftop（推荐） - 实时流量监控
iftop是一个类似 top的网络流量监控工具，可以按进程/连接实时显示网络带宽使用情况。

安装 iftop

sudo apt update
sudo apt install iftop

基本用法

sudo iftop

常用参数

参数 说明
-i <网卡>
指定监控的网卡（如 eth0、wlan0）
-n
不解析主机名（加快显示速度）
-P
显示端口号
-B
以字节（Bytes）为单位显示流量

示例：

sudo iftop -i eth0 -nP

界面说明：

​​上半部分​​：显示带宽使用情况（发送/接收）。
​​下半部分​​：按连接显示流量（IP:Port）。
​​排序​​：按 T（发送流量）、R（接收流量）、2（2秒刷新）调整。

2. nload- 简单直观的流量监控​​
   nload提供更简洁的界面，适合快速查看带宽占用。

安装 nload

sudo apt install nload

基本用法

nload

Docker搭建samba服务

docker run -d \
  --name docker-samba \
  -e NAME="NAS" \
  -e USER="iuu" \
  -e PASS="iuuiuuiuu" \
  -p 139:139 \
  -p 445:445 \
  -v /home/iuu/storage/:/storage \
  --restart always \
  dockurr/samba

MoonTV安装

  docker run -d \
  --name moontv-core \
  --restart on-failure \
  -p 3000:3000 \
  -e USERNAME=用户 \
  -e PASSWORD=密码 \
  -e NEXT_PUBLIC_STORAGE_TYPE=kvrocks \
  -e KVROCKS_URL=redis://moontv-kvrocks:6666 \
  -e AUTH_TOKEN=7113f6e645cf82558c8e40d030e59195 \
  --network moontv-network \
  99fb52e42dd6

  docker run -d \
  --name moontv-kvrocks \
  --restart unless-stopped \
  --network moontv-network \
  apache/kvrocks 

在Java中，我们经常看到public、protected、private这些修饰符。在Java中，这些修饰符可以用来限定访问作用域。

public
定义为public的class、interface可以被其他任何类访问：

package abc;

public class Hello {
    public void hi() {
    }
}

上面的Hello是public，因此，可以被其他包的类访问：

package xyz;

class Main {
    void foo() {
        // Main可以访问Hello
        Hello h = new Hello();
    }
}

定义为public的field、method可以被其他类访问，前提是首先有访问class的权限：

package abc;

public class Hello {
    public void hi() {
    }
}

上面的hi()方法是public，可以被其他类调用，前提是首先要能访问Hello类：

package xyz;

class Main {
    void foo() {
        Hello h = new Hello();
        h.hi();
    }
}

private
定义为private的field、method无法被其他类访问：

package abc;

public class Hello {
    // 不能被其他类调用:
    private void hi() {
    }

    public void hello() {
        this.hi();
    }
}

实际上，确切地说，private访问权限被限定在class的内部，而且与方法声明顺序无关。推荐把private方法放到后面，因为public方法定义了类对外提供的功能，阅读代码的时候，应该先关注public方法：

package abc;

public class Hello {
    public void hello() {
        this.hi();
    }

    private void hi() {
    }
}

由于Java支持嵌套类，如果一个类内部还定义了嵌套类，那么，嵌套类拥有访问private的权限：

// private
public class Main {
    public static void main(String[] args) {
        Inner i = new Inner();
        i.hi();
    }

    // private方法:
    private static void hello() {
        System.out.println("private hello!");
    }

    // 静态内部类:
    static class Inner {
        public void hi() {
            Main.hello();
        }
    }
}

定义在一个class内部的class称为嵌套类（nested class），Java支持好几种嵌套类。

protected
protected作用于继承关系。定义为protected的字段和方法可以被子类访问，以及子类的子类：

package abc;

public class Hello {
    // protected方法:
    protected void hi() {
    }
}

上面的protected方法可以被继承的类访问：

package xyz;

class Main extends Hello {
    void foo() {
        // 可以访问protected方法:
        hi();
    }
}

package
最后，包作用域是指一个类允许访问同一个package的没有public、private修饰的class，以及没有public、protected、private修饰的字段和方法。

package abc;
// package权限的类:
class Hello {
    // package权限的方法:
    void hi() {
    }
}

只要在同一个包，就可以访问package权限的class、field和method：

package abc;

class Main {
    void foo() {
        // 可以访问package权限的类:
        Hello h = new Hello();
        // 可以调用package权限的方法:
        h.hi();
    }
}

注意，包名必须完全一致，包没有父子关系，com.apache和com.apache.abc是不同的包。

局部变量
在方法内部定义的变量称为局部变量，局部变量作用域从变量声明处开始到对应的块结束。方法参数也是局部变量。

package abc;

public class Hello {
    void hi(String name) { // 1
        String s = name.toLowerCase(); // 2
        int len = s.length(); // 3
        if (len < 10) { // 4
            int p = 10 - len; // 5
            for (int i=0; i<10; i++) { // 6
                System.out.println(); // 7
            } // 8
        } // 9
    } // 10
}

我们观察上面的hi()方法代码：

方法参数name是局部变量，它的作用域是整个方法，即1 ~ 10；
变量s的作用域是定义处到方法结束，即2 ~ 10；
变量len的作用域是定义处到方法结束，即3 ~ 10；
变量p的作用域是定义处到if块结束，即5 ~ 9；
变量i的作用域是for循环，即6 ~ 8。
使用局部变量时，应该尽可能把局部变量的作用域缩小，尽可能延后声明局部变量。

final
Java还提供了一个final修饰符。final与访问权限不冲突，它有很多作用。

用final修饰class可以阻止被继承：

package abc;

// 无法被继承:
public final class Hello {
    private int n = 0;
    protected void hi(int t) {
        long i = t;
    }
}

用final修饰method可以阻止被子类覆写：

package abc;

public class Hello {
    // 无法被覆写:
    protected final void hi() {
    }
}

用final修饰field可以阻止被重新赋值：

package abc;

public class Hello {
    private final int n = 0;
    protected void hi() {
        this.n = 1; // error!
    }
}

用final修饰局部变量可以阻止被重新赋值：

package abc;

public class Hello {
    protected void hi(final int t) {
        t = 1; // error!
    }
}