一杯西瓜汁er🍉
0%

发表于
本文字数： 127 阅读时长 ≈ 1 分钟

在服务器上下载imagenet的训练数据总是断开，于是想要能够像rsync一样的断点续传功能。

1
wget -c -t 100 URL

其中，-c表示断点续传，-t 100代表重试100次，-t 0 表示无穷次重试直至成功连接。

参考：wget命令详解(断点续传,批量下载)

发表于
本文字数： 157 阅读时长 ≈ 1 分钟

实习小半年了，经常用到/也学到了一些好用的Linux命令，记录一下。 方便日后查阅。

  • 查看当前目录下的进程 

    1
    lsof +D ./

  • 查看占用端口为8076的进程 

    1
    2
    3
    lsof -i:8076
    # 解除端口占用 / 杀死该进程
    kill -9 进程号

  • 查看日志目录下有无panic字样 

    1
    2
    cd logs/ # 先进入日志目录下
    grep panic ./ -r

发表于
本文字数： 854 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class UF {
    private int count;  // 集合数量
    private int[] parent;  //父结点
    private int[] size;   // 每个集合的大小
    public UF(int n) {
        this.count = n;
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }
    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        // 如果根相同，说明已经在同一个集合中，直接返回
        if (rootP == rootQ) return ;
        // 平衡性优化
        if (size[rootP] < size[rootQ]) {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        } else {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        }
        this.count--;
    }
    public boolean conneted(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        return rootP == rootQ;
    }
    public int count() {
        return this.count;
    }
    private int find(int x) {
        // 路径压缩
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
}

参考

详解：并查集（Union-Find）

发表于
本文字数： 1.2k 阅读时长 ≈ 1 分钟

两阶段终止模式

优雅地终止线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import  lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "Test3")
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        TwoStageTermination t = new TwoStageTermination();
        t.start();
        Thread.sleep(5000);
        t.stop();
    }
}

/**
 * 两阶段终止模式
 */
@Slf4j(topic = "TwoStageTermination")
class TwoStageTermination{
    private Thread monitor;
    // 启动监控线程

    public void start(){
        monitor = new Thread(() -> {
            while(true){
                Thread current = Thread.currentThread();
                if(current.isInterrupted()){
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);  //  情况1
                    log.debug("执行监控记录");   // 情况2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 重新设置打断标记（因为sleep打断的时候会清除打断标记
                    current.interrupt();
                }
            }
        });
        monitor.start();
    }

    // 停止监控线程
    public void stop(){
        monitor.interrupt();
    }
}

interrupt相关

  1. 打断

关于interrupt的api

方法 作用 备注
isInterrupted() 判断是否被打断 不会清除打断标记
interrupted() static方法，判断是否被打断 会清除打断标记（设为false）
interrupt() 打断线程 如果打断阻塞线程，会抛出InterruptedException异常，并清除打断标记（设为false）；如果打算正常线程，则会设置打断标记（设为true）；park线程也会被打断，也会设置打断标记
  1. 打断阻塞线程（sleep、join、wait）

打断sleep线程，会抛出异常, 清空打断状态，即打断标记为false

  1. 打断正常线程

不会对线程产生影响，设置打断标记，设为true

发表于
本文字数： 479 阅读时长 ≈ 1 分钟
  1. 锁对象

一种写法：

this是指本对象，锁的是该对象，是一个实例。

1
2
3
4
5
6
7
8
class Room{
    private int counter = 0;
    public void increment(){
        synchronized (this){
            counter++;
        }
    }
}

另一种写法，是把synchronized加在方法上：

1
2
3
4
5
6
class Room{
    private int counter = 0;
    public synchronized void increment(){
        counter++;
    }
}
  1. 锁类

一种写法，是锁类

1
2
3
4
5
class Test{
    public synchronized static void test(){
        // 
    }
}

另一种写法，是加在静态方法上

1
2
3
4
5
6
7
class Test{
    public static void test(){
        synchronized(Test.class){
            //
        }
    }
}

发表于
本文字数： 119 阅读时长 ≈ 1 分钟

rsync

使用ssh的同步文件的工具，用来传输文件很方便，可以断点续传！

常用：

1
2

rsync -av -e 'ssh -p 222' source/ user@remote_host:/destination

参考：rsync 用法教程

发表于
本文字数： 128 阅读时长 ≈ 1 分钟

写在前：在深度学习中，数据集通常比较大，占用的存储空间较多。而很多项目会基于同一个数据集进行实验。

所以，强烈推荐将数据集放在项目外，并通过软链接的方式链接到项目中的data/目录下。

补充软链接的用法：

1
ln -s 原始路径 目的路径

注意：原始路径必须写绝对路径。

发表于
本文字数： 319 阅读时长 ≈ 1 分钟

总要配置环境，记下步骤来就方便很多啦～ linux: Ubuntu 18.04 LTS

  1. 下载最新版本的miniconda
1
wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh
  1. 安装miniconda
1
sh Miniconda3-latest-Linux-x86_64.sh

安装过程中可以指定安装目录

并 running conda init

  1. 查看conda的配置
1
cat .bashrc
  1. 让配置生效
1
source ~/.bashrc
  1. 查看正在使用的conda
1
2
which conda
# /home/zsx/miniconda3/bin/conda

=== 至此，conda就安装好啦

发表于
本文字数： 410 阅读时长 ≈ 1 分钟

记录常用的linux命令

1
2
3
4
$ scp
usage: scp [-346BCpqrTv] [-c cipher] [-F ssh_config] [-i identity_file]
            [-J destination] [-l limit] [-o ssh_option] [-P port]
            [-S program] source ... target

常用：传输文件夹，前面是src，后面是dest 

1
scp -P 端口号 -r 本地文件夹路径 用户名@xxx.xxx.xxx.xxx:服务器上的文件路径
注意：端口号要紧跟scp命令后面，不要放在最后

比如：

1
scp -P 222 -r ./folder/ 用户名@xxx.xxx.xxx.xxx:/home/zsx/projects/

就会将本地当前路径下的folder文件夹传到服务器的/home/zsx/projects/目录下

最最最后，刚写完这个post就发现一篇解释得很详细的文章~ 指路：linux scp命令安全远程文件复制程序