2024-08-09

在Linux下,实现线程互斥(也称为加锁)通常使用pthread库中的pthread_mutex_t类型和相关函数。以下是一个简单的例子,展示了如何使用互斥锁来同步两个线程对共享资源的访问。




#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 定义互斥锁
int shared_resource = 0; // 共享资源
 
void* thread_function_1(void* arg) {
    while(1) {
        pthread_mutex_lock(&mutex); // 加锁
        shared_resource++;
        printf("Thread 1: %d\n", shared_resource);
        pthread_mutex_unlock(&mutex); // 解锁
        sleep(1);
    }
    return NULL;
}
 
void* thread_function_2(void* arg) {
    while(1) {
        pthread_mutex_lock(&mutex); // 加锁
        shared_resource--;
        printf("Thread 2: %d\n", shared_resource);
        pthread_mutex_unlock(&mutex); // 解锁
        sleep(1);
    }
    return NULL;
}
 
int main() {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, &thread_function_1, NULL);
    pthread_create(&thread2, NULL, &thread_function_2, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    return 0;
}

在这个例子中,我们定义了一个互斥锁mutex和一个共享资源shared_resource。两个线程函数thread_function_1thread_function_2通过互斥锁来确保它们在访问shared_resource时不会被打断。每个线程都会在加锁后对shared_resource进行操作,然后解锁,保证了同一时刻只有一个线程可以访问资源。

2024-08-09

在 Linux 中,使用 vivim 编辑器时,可以通过以下步骤保存和退出:

  1. 保存文件:

    • Esc 键进入命令模式。
    • 输入 :w 然后按 Enter 键保存文件。
  2. 保存并退出:

    • Esc 键进入命令模式。
    • 输入 :wq 然后按 Enter 键保存并退出。
  3. 强制保存并退出(在没有写权限的情况下):

    • Esc 键进入命令模式。
    • 输入 :wq! 然后按 Enter 键强制保存并退出。
  4. 不保存并退出:

    • Esc 键进入命令模式。
    • 输入 :q! 然后按 Enter 键不保存并强制退出。
  5. 退出(如果文件没有更改):

    • Esc 键进入命令模式。
    • 输入 :q 然后按 Enter 键退出。

请注意,在实际使用中,你可以直接按 Esc 键进入命令模式,然后输入 :w:wq 等命令,不需要先按 Enter,然后再输入命令。你可以连续输入命令,系统会在你按下最后一个命令的最后一个按键时执行命令。

2024-08-09



#!/bin/bash
 
# 设定变量
VG_NAME="vg01"
LV_NAME="lv01"
MOUNT_POINT="/mnt/mylv"
 
# 查看当前VG的信息
echo "当前卷组信息:"
vgs ${VG_NAME}
 
# 检查逻辑卷是否已经挂载,如果已经挂载,则卸载
if mount | grep "${MOUNT_POINT}"; then
    umount ${MOUNT_POINT}
fi
 
# 扩展逻辑卷到19.50GiB
lvextend -L 19.50GiB /dev/${VG_NAME}/${LV_NAME}
 
# 扩展文件系统
resize2fs /dev/${VG_NAME}/${LV_NAME}
 
# 重新挂载逻辑卷
mount /dev/${VG_NAME}/${LV_NAME} ${MOUNT_POINT}
 
# 确认逻辑卷的新大小
lvs ${VG_NAME}/${LV_NAME}

这段代码首先定义了卷组名称、逻辑卷名称和挂载点。然后,它检查逻辑卷是否已经挂载,如果是,则先卸载。接下来,它使用lvextend命令将逻辑卷扩展到19.50GB。最后,使用resize2fs命令扩展文件系统,并重新挂载逻辑卷。

2024-08-09

在Linux中,可以使用kill命令发送信号给进程,并使用trap命令在脚本中处理信号。

以下是一个简单的示例,展示了如何在Shell脚本中捕获SIGINT信号并对其进行处理:




#!/bin/bash
 
trap "echo '捕获到SIGINT信号,进行清理工作。'" SIGINT
 
echo "脚本正在运行,按Ctrl+C发送SIGINT信号。"
 
# 模拟一个长时间运行的进程
while true
do
    sleep 1
done

当你运行这个脚本并按下Ctrl+C时,会触发SIGINT信号,该信号被trap命令捕获,并执行定义的命令进行处理。

如果你想将信号写入文件,可以使用kill命令配合tee命令。例如,将SIGINT信号写入文件:




kill -s SIGINT $(ps -ef | grep my_script.sh | grep -v grep | awk '{print $2}') | tee signal.txt

这条命令会发送SIGINT信号给名为my_script.sh的进程,并将信号编号2(对应SIGINT)写入signal.txt文件。

2024-08-09

watch 命令在 Linux 系统中用于定期执行给定的命令,并实时显示输出结果。它可以周期性地执行命令,并且能够清晰地显示输出的变化。

基本语法如下:




watch [options] command

例如,要实时监控 ls 命令的输出,可以使用:




watch -n 1 ls

这里 -n 1 表示更新频率为每秒一次。

其他常用选项包括:

  • -d: 高亮显示变动的部分。
  • -t: 不显示命令的时间戳。
  • -n: 指定更新的频率(秒)。

实例代码:




# 实时监控当前目录文件列表
watch -d -n 2 ls -l
 
# 实时监控系统负载情况
watch -n 2 uptime
 
# 实时监控内存使用情况
watch -n 2 free -m

以上命令会每隔两秒更新一次,并以高亮形式显示变动的部分。

2024-08-09

在Linux和Windows上安装Vue CLI的步骤相同,都需要使用npm或yarn作为包管理器。以下是安装Vue CLI的步骤:

  1. 确保你已经安装了Node.js和npm。可以访问Node.js官网安装。
  2. 在命令行中运行以下命令全局安装Vue CLI:

    
    
    
    npm install -g @vue/cli

    或者如果你使用yarn:

    
    
    
    yarn global add @vue/cli
  3. 安装完成后,你可以通过运行以下命令来检查Vue CLI是否安装成功:

    
    
    
    vue --version

    如果安装成功,这个命令会输出Vue CLI的版本号。

  4. 创建一个新的Vue项目,可以使用Vue CLI的命令:

    
    
    
    vue create my-project

    其中my-project是你的项目名称。

以上步骤在Linux和Windows上应该是一样的。如果遇到任何特定于平台的问题,请确保你的环境变量配置正确,并且有相应的权限来安装全局包。

2024-08-09



#!/bin/sh
# 设置INPUT链默认策略为DROP
iptables -P INPUT DROP
# 设置FORWARD链默认策略为DROP
iptables -P FORWARD DROP
# 设置OUTPUT链的默认策略为ACCEPT
iptables -P OUTPUT ACCEPT
 
# 允许来自本机的流量
iptables -A INPUT -i lo -j ACCEPT
# 允许已经建立的连接的流量
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# 允许SSH连接(可以根据需要更改端口号)
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# 允许HTTP连接
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
# 允许HTTPS连接
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
 
# 保存配置
iptables-save > /etc/iptables/rules.v4
# 如果需要,可以重载配置
# iptables-restore < /etc/iptables/rules.v4
 
# 注释:
# -P 用来设置默认策略
# -A 用来添加规则
# -i 指定入接口
# -o 指定出接口
# -p 指定协议
# --dport 指定目标端口
# --sport 指定源端口
# -j 指定动作,如 ACCEPT, DROP 等
# -m state --state 用来匹配状态,ESTABLISHED代表已建立的连接,RELATED代表该连接的相关连接

这段代码提供了一个简单的iptables安全策略示例,包括设置默认策略、允许特定的服务和流量,并保存配置。开发者可以根据自己的需求修改端口号和允许的服务类型。

2024-08-09

在Linux中,删除文件和文件夹的命令是rm。以下是一些常用的rm命令选项:

  • 删除单个文件:rm 文件名
  • 删除多个文件:rm 文件名1 文件名2
  • 删除文件夹及其所有内容(递归删除):rm -r 文件夹名
  • 强制删除,不询问确认:rm -f 文件名
  • 同时使用递归和强制选项:rm -rf 文件夹名

请注意,使用rm命令要小心,因为删除后的文件通常不能恢复。

示例代码:




rm myfile.txt        # 删除名为myfile.txt的文件
rm myfile1.txt myfile2.txt # 同时删除两个文件
rm -r myfolder       # 删除名为myfolder的文件夹及其所有内容
rm -f myfile.txt     # 强制删除名为myfile.txt的文件
rm -rf myfolder      # 强制删除名为myfolder的文件夹及其所有内容
2024-08-09



# 创建一个简单的ISO文件,包含了指定目录下的内容
mkisofs -o simple.iso /path/to/files
 
# 创建一个带有启动信息的ISO文件,设置启动文件和启动菜单
mkisofs -o bootable.iso -V "Label" -b boot/boot.bin -c boot/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table /path/to/files
 
# 创建一个带有密码保护的ISO文件
mkisofs -o password-protected.iso -V "Label" -p -P -J -r -v -o /path/to/files
 
# 注意事项:
# -V 参数后跟的是卷标签(Volume Label)
# -b 参数指定了启动扇区的二进制文件
# -c 参数指定了用于构建启动菜单的cat文件
# -no-emul-boot 禁用模拟引导
# -boot-load-size 指定了加载引导文件的大小
# -boot-info-table 启用引导信息表
# -p 和 -P 参数启用密码保护
# -J 参数生成Joliet目录记录,提供Unix文件名支持
# -r 参数使用Rock Ridge文件名扩展
# -v 参数创建可启动的ISO
# -o 参数后面跟输出的ISO文件名

这个例子展示了如何使用mkisofs命令来创建不同类型的ISO文件,包括简单的ISO、可启动的ISO以及带有密码保护的ISO。每个选项的含义都有详细的注释,并且提供了如何使用这些选项的实例。

2024-08-09

在Linux内核中,kobjectksetktype是构成系统对象模型的三个核心组件,它们允许内核提供一个统一的方式来表示和管理系统资源。

  • kobject:每个内核对象都有一个kobject结构体,它封装了引用计数、对象类型和生命周期管理的函数。
  • ksetkset是内核对象的集合,它们之间通过kobject建立关联,形成层次结构。
  • ktypektype定义了一个特定类型的内核对象的操作方法。

举例来说,如果你想要在内核中表示一个设备,你可以定义一个ktype来管理设备的特定操作,然后将其作为一个对象加入到kset中去。

下面是一个简化的例子,展示了如何在内核中创建一个简单的内核对象:




#include <linux/kobject.h>
#include <linux/module.h>
 
// 定义一个ktype,用于管理我们的对象操作
static struct kobj_type example_ktype = {
    .sysfs_ops = NULL,
    .default_attrs = NULL,
};
 
// 定义一个kset,用于存放我们的对象
static struct kset *example_kset;
 
static int __init example_init(void)
{
    struct kobject *kobject;
    
    // 创建kset(如果需要的话)
    example_kset = kset_create_and_add("example", NULL, kernel_kobj);
    if (!example_kset)
        return -ENOMEM;
 
    // 创建一个kobject并将其添加到kset中
    kobject = kobject_create_and_add("my_object", example_kset);
    if (!kobject) {
        kset_unregister(example_kset);
        return -ENOMEM;
    }
 
    // 初始化kobject并设置ktype
    kobject_init(kobject, &example_ktype);
 
    return 0;
}
 
static void __exit example_exit(void)
{
    kobject_put(&kobject); // 引用计数减一,当计数为零时删除对象
    kset_unregister(example_kset); // 删除kset
}
 
module_init(example_init);
module_exit(example_exit);
 
MODULE_LICENSE("GPL");

在这个例子中,我们创建了一个名为examplekset,然后创建了一个名为my_objectkobject并将其关联到examplekset中。我们还定义了一个ktype来管理我们的对象,并通过kobject_init初始化了kobject并设置了ktype。最后,在模块卸载时,我们通过kobject_putkset_unregister来清理资源。