笔记-LINUX

du -sh 在不指定目录的情况下，默认会显示当前目录下的所有子目录的总大小。
du -sh 目录名 在指定目录的情况下，会显示指定目录下的所有文件或文件夹的大小。
du -sh * # 显示当前目录下的所有文件和文件夹大小
du -sh / # 显示根目录下所有的文件和文件夹大小
du -sh /data # 显示/data目录下所有的文件和文件夹大小

df -h (-h参数使结果以K，M，G为单位，提高信息的可读性)

不同：

df 是从总体上统计系统各磁盘的**占用情况**，不能统计具体的文件夹或文件的大小。
du 既可以从总体上统计，又可以统计具体的某个文件夹或文件的**大小**。

df 通过文件系统来快速获取空间大小的信息，速度快，效率高
du通过逐级进入指定目录的每一个子目录，逐个计算每个文件大小并相加，最终显示出来。 所以计算速度慢，当文件目录较多文件较大时要等很久很久！！

df 可以获取已经删除的文件。当所有程序都不用时，才会根据OS的规则释放掉已经删除的文件。所以当一个文件刚删除清空没完全释放时，df 仍会把它计算在内。
du 只能看到当前存在的、没有被删除的文件。

vda1 代表系统盘分了几个区，数字往后递增

C++互斥量：
头文件：#include<mutex>
属于std命名空间
使用:
std::mutex m;
m.lock(); m.unlock();

C++ 计时互斥量：
头文件：#include<mutex>
属于std命名空间
使用：
std::timed_mutex mtx;
mtx.try_lock_for(timeout) ;
mtx.unlock() ;

C++条件变量：
头文件：#include <condition_variable>
属于std命名空间
使用：
std::condition_variable cv;
cv.wait(lock); //释放持有的互斥锁
cv.notify_one(); / cv.notify_all();

std::lock_guard 是 C++ 标准库提供的一个 RAII 风格的互斥锁封装，用于在代码块中自动获取互斥锁，并在离开该代码块时自动释放互斥锁，从而避免了手动加锁解锁的错误和繁琐。
使用方式：
std::lock_guard<std::mutex> lock(mtx); //mtx是要获取的互斥锁

1. unique_lock比lock_guard更加灵活，可以在构造时不加锁，也可以在中途解锁或重新加锁，还可以转移所有权。(①调用unique_lock的lock和unlock函数中途解锁，或者再加锁 ②调用unique_lock的release函数释放unique_lock对象所有权，并返回一个指针，可以通过指针完成lock和unlock操作 ③使用Move移动语义将一个unique_lock对象转移给另一个unique_lock对象)
2. unique_lock比lock_guard占用更多的空间和时间，因为它要维护锁的状态，并提供更多的成员函数。

//使用unlock()成员函数
std::mutex mtx;
std::unique_lock<std::mutex> lck(mtx); //构造时加锁
//do some work
lck.unlock(); //中途解锁
//do some other work
lck.lock(); //重新加锁

//使用release()成员函数
std::mutex mtx;
std::unique_lock<std::mutex> lck(mtx); //构造时加锁
//do some work
std::mutex* ptr = lck.release(); //释放所有权并返回指针
//do some other work
ptr->lock(); //手动加锁
delete ptr; //手动释放指针

//使用移动语义
std::mutex mtx;
std::unique_lock<std::mutex> lck1(mtx); //构造时加锁
//do some work
std::unique_lock<std::mutex> lck2(std::move(lck1)); //转移所有权给lck2
//do some other work
lck2.unlock(); //解锁

信号量直到 C++20 才被支持
在C11实现信号量需要维护一个计数，当计数不够用时，阻塞到条件变量里。

#ifndef _SEMAPHORE_H
#define _SEMAPHORE_H
#include <mutex>
#include <condition_variable>
using namespace std;
 
class Semaphore
{
public:
    Semaphore(long count = 0) : count(count) {}
    //V操作，唤醒
    void signal()
    {
        unique_lock<mutex> unique(mt);
        ++count;
        if (count <= 0)
            cond.notify_one();
    }
    //P操作，阻塞
    void wait()
    {
        unique_lock<mutex> unique(mt);
        --count;
        if (count < 0)
            cond.wait(unique);
    }
    
private:
    mutex mt;
    condition_variable cond;
    long count;
};
#endif

C++实现交替打印：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

using namespace std;

mutex mtx;
condition_variable cv;
bool flag = false;

void printNum(int num) {
    for (int i = 1; i <= num; i++) {
        unique_lock<mutex> lock(mtx);
        while (flag) cv.wait(lock);
        cout << i;
        flag = true;
        cv.notify_all();
    }
}

void printChar(char ch) {
    for (int i = 0; i < 3; i++) {
        unique_lock<mutex> lock(mtx);
        while (!flag) cv.wait(lock);
        cout << ch;
        flag = false;
        cv.notify_all();
    }
}

int main() {
    thread t1(printNum, 3);
    thread t2(printChar, 'a');
    thread t3(printChar, 'b');
    thread t4(printChar, 'c');
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    return 0;
}

ps命令：
a显示所有进程，包括其他用户的。
u使用面向用户的格式，提供有关进程的详细信息
x显示所有程序，不以终端机来区分
ps结果有：
进程ID，CPU/内存占用，进程状态，正在执行的命令行命令
状态包括：

S表示等待某个事件完成，可以被唤醒。D 状态表示进程处于不可中断睡眠状态，通常是等待 IO 事件 。
Ctrl + C 发送 SIGINT信号，终止进程
Ctrl + Z 发送 SIGTSTP 信号，程序暂停 ，但并没有释放内存 ，此时在的进程是挂起转态，可以使用 fg 和bg 命令 前台或 后台 继续该任务

top -p
观察指定pid进程
默认按照CPU使用率排序，可以在结果界面按M(MEM),N(PID),P(CPU)切换