那请举例说明内核线程怎么使用互斥锁

内核线程是在Linux内核层面运行的线程，它们与用户空间的线程有所不同。在内核中，我们可以使用互斥锁进行多个内核线程之间的同步。

下面是一个简单的内核模块示例，它创建了两个内核线程，这两个线程会轮流访问一个共享的计数器，并使用互斥锁进行同步：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/mutex.h>

static struct task_struct *thread1, *thread2;
static int counter = 0;
static DEFINE_MUTEX(mutex);

int thread_func(void *data) {
    int i;
    for (i = 0; i < 5; i++) {
        mutex_lock(&mutex);
        counter++;
        printk(KERN_INFO "Counter incremented by %d\n", counter);
        mutex_unlock(&mutex);
        msleep(1000);
    }
    return 0;
}

static int __init my_module_init(void) {
    mutex_init(&mutex);
    thread1 = kthread_create(thread_func, NULL, "my_thread1");
    if (IS_ERR(thread1)) {
        printk(KERN_INFO "Failed to create thread1\n");
        return PTR_ERR(thread1);
    }
    wake_up_process(thread1);
    thread2 = kthread_create(thread_func, NULL, "my_thread2");
    if (IS_ERR(thread2)) {
        printk(KERN_INFO "Failed to create thread2\n");
        kthread_stop(thread1);
        return PTR_ERR(thread2);
    }
    wake_up_process(thread2);
    return 0;
}

static void __exit my_module_exit(void) {
    kthread_stop(thread1);
    kthread_stop(thread2);
    mutex_destroy(&mutex);
}

module_init(my_module_init);
module_exit(my_module_exit);

在上面的代码中，我们首先定义了一个共享的计数器`counter`，然后创建了两个内核线程`thread1`和`thread2`，这两个线程会轮流访问计数器，并使用互斥锁`mutex`进行同步。

在线程函数`thread_func`中，我们使用`mutex_lock`函数对互斥锁进行加锁操作，然后对计数器进行加1操作，并打印出新的计数器值。在操作完成后，我们使用`mutex_unlock`函数对互斥锁进行解锁操作。这样可以保证在任何时刻，只有一个线程可以访问计数器。

在模块的初始化函数`my_module_init`中，我们首先使用`mutex_init`函数对互斥锁进行初始化。然后创建两个内核线程，并使用`wake_up_process`函数启动它们。在模块的退出函数`my_module_exit`中，我们使用`kthread_stop`函数停止内核线程，并使用`mutex_destroy`函数销毁互斥锁。

需要注意的是，在内核中，我们可以使用`mutex_lock`和`mutex_unlock`函数对内核互斥锁进行加锁和解锁操作，这些函数与用户空间的`pthread_mutex_lock`和`pthread_mutex_unlock`函数使用方法类似，但是函数名略有不同。