AI 助理
备案控制台
开发者社区 大数据与机器学习 文章 正文

多线程编程

2023-06-10 92
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
实时计算 Flink 版，5000CU*H 3个月
推荐场景：
实时发现最热Github项目
检索分析服务 Elasticsearch 版，2核4GB开发者规格 1个月
推荐场景：
数据可视化分析航班信息
智能开放搜索 OpenSearch行业算法版，1GB 20LCU 1个月
推荐场景：
搭建高质量商品搜索服务
简介： 主要参考韦东山老师的文档，如果没基础，直接看文档，别看视频！！！学习中。。。

多线程编程

基本概念

进程：PID

线程：tid

线程号与进程号是表示线程和进程的唯一标识，但是对于线程号而言 ，其仅仅在其所属的进程上下文中才有意义。

获取线程号

#include <pthread.h>
#include <stdio.h>
int main()
{
   
   
    pthread_t tid = pthread_self();
    printf("tid = %lu\n",(unsigned long)tid);
    return 0;
}
编译：gcc Pthread_Text1.c -lpthread

创建线程

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun(void *arg)
{
   
   
    printf("pthread_New = %lu\n",(unsigned long)pthread_self());
}

int main()
{
   
   

    pthread_t tid1;
    int ret = pthread_create(&tid1,NULL,fun,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }

    /*tid_main 为通过pthread_self获取的线程ID，tid_new通过执行pthread_create成功后tid指向的空间*/
    printf("tid_main = %lu tid_new = %lu \n",(unsigned long)pthread_self(),(unsigned long)tid1);

    /*因线程执行顺序随机，不加sleep可能导致猪线程先执行，导致进程结束，无法执行到子线程*/
    sleep(1);

    return 0;
}

output:
book@100ask:~/my_source$ ./a.out
tid_main = 139951278651200 tid_new = 139951270156032
pthread_New = 139951270156032
#如果不加sleep(1)根本执行不到子线程，因为执行顺序是随机的，并不能保证哪个进程先执行，因此如果先执行主线程，就会直接导致无法执行子线程，输出如下
book@100ask:~/my_source$ ./a.out
tid_main = 139857541936960 tid_new = 139857533441792

如此可以说明，线程的执行顺序不受控制，且整个进程结束后所产生的线程也随之被释放

线程传参

第四个参数传递有地址传递方式和变量传递方式两种

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
}

void *fun2(void *arg)
{
   
   
    printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
}

int main()
{
   
   

    pthread_t tid1,tid2;
    int a = 50;
    //地址方式传递
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    // 值方式传递
    ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
    if(ret != 0){
   
   
        //相对于printf能输出更多的错误信息
        perror("pthread_create");
        return -1;
    }
    sleep(1);
    printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    return 0;
}

注意这块传值的时候，如果是地址方式传值，当变量发生改变时候，其地址对应的变量也会发生改变，但是如果使用变量传值的时候，当指针指向的变量发生改变，其传入的变量值不会发生变化，如下例程：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    while(1){
   
   

        printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
        sleep(1);
    }
}

void *fun2(void *arg)
{
   
   
    while(1){
   
   

        printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
        sleep(1);
    }
}

int main()
{
   
   

    pthread_t tid1,tid2;
    int a = 50;
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    sleep(1);
    ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    while(1){
   
   
        a++;
        sleep(1);
        printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    }
    return 0;
}
//下面输出的顺序是乱的，因为线程执行的顺序不受控制，注意值传递和地址传递的区别！！！

image-20230610164042177

传递多个参数：结构体

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

struct Stu{
   
   
    int Id;
    char Name[32];
    float Mark;
};

void *fun1(void *arg)
{
   
   
    struct Stu *tmp = (struct Stu *)arg;
    printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,tmp->Id,tmp->Name,tmp->Mark);

}

int main()
{
   
   

    pthread_t tid1,tid2;
    struct Stu stu;
    stu.Id = 10000;
    strcpy(stu.Name,"ZhangSan");//字符串拷贝
    stu.Mark = 94.6;

    int ret = pthread_create(&tid1,NULL,fun1,(void *)&stu);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,stu.Id,stu.Name,stu.Mark);
    sleep(1);
    return 0;
}

image-20230610164556622

线程的退出和回收

线程主动退出

image-20230610164832914

线程被动退出

image-20230610164855950

线程资源回收（阻塞方式）

image-20230610164934777

第一个参数为要回收线程的tid号，第二个参数为线程回收后接收线程传出的数据

线程资源回收（非阻塞方式）

image-20230610165039768

阻塞方式回收线程：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    static int tmp = 0;//必须要static修饰，为变量的生命周期做延续，否则pthread_join无法获取到正确的值
    //int tmp = 0;
    tmp = *(int *)arg;
    tmp+=100;
    printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
    pthread_exit((void *)&tmp);
}


int main()
{
   
   

    pthread_t tid1;
    int a = 50;
    void *Tmp = NULL;
    int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    //这里不用sleep，是因为pthread_join函数具备阻塞他行，直到成功收回线程才会冲破阻塞，因此不用考虑主线程执行到最后结束线程的情况。
    pthread_join(tid1,&Tmp);//&Tmp就相当于接收线程传出的数据，上面fun1传出的数据
    printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
    return 0;
}

通过阻塞方式回收线程几乎规定了线程回收的顺序，若最先回收的线程未退出，则一直会被阻塞，导致后续先退出的线程无法及时的回收。

非阻塞方式回收线程

通过函数pthread_tryjoin_np，使用非阻塞回收，线程可以根据退出先
后顺序自由的进行资源的回收。

多个线程可以指向同一个回调函数

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun(void *arg)
{
   
   
    printf("Pthread:%d Come !\n",(int )(long)arg+1);
    pthread_exit(arg);
}
int main()
{
   
   
    int ret,i,flag = 0;
    void *Tmp = NULL;
    pthread_t tid[3];
    for(i = 0;i < 3;i++){
   
   
        ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
        if(ret != 0){
   
   
            perror("pthread_create");
            return -1;
        }
    }
    while(1){
   
   
        for(i = 0;i <3;i++){
   
   
            if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
   
   
                printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
                flag++;    
            }
        }
        if(flag >= 3) break;
    }
    return 0;
}

image-20230610171851090

pthread_cancel主动结束线程

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    // 第一个进程为死循环睡眠状态
    printf("Pthread:1 come!\n");
    while (1)
    {
   
   
        sleep(1);
    }
}

void *fun2(void *arg)
{
   
   
    printf("Pthread:2 come!\n");
    pthread_cancel((pthread_t)(long)arg); // 退出第一个进程，传入第一个线程的线程号
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret, i, flag = 0;
    void *Tmp = NULL;
    pthread_t tid[2];
    ret = pthread_create(&tid[0], NULL, fun1, NULL);
    if (ret != 0)
    {
   
   
        perror("pthread_create");
        return -1;
    }
    // 确保必须线程1先执行，因为线程是无序的，因此加入睡眠控制函数控制顺序
    sleep(1);
    ret = pthread_create(&tid[1], NULL, fun2, (void *)tid[0]);
    if (ret != 0)
    {
   
   
        perror("pthread_create");
        return -1;
    }
    while (1)
    {
   
   
        for (i = 0; i < 2; i++)
        {
   
   
            if (pthread_tryjoin_np(tid[i], NULL) == 0)
            {
   
    // 尝试回收线程
                printf("Pthread : %d exit !\n", i + 1);
                flag++;
            }
        }
        if (flag >= 2)
            break;
    }
    return 0;
}

线程的控制

多线程编程临界资源访问

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>


int Num = 0;

void *fun1(void *arg)
{
   
   
    while(Num < 3){
   
   
        Num++;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    while(Num > -3){
   
   
        Num--;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2;
    ret = pthread_create(&tid1,NULL,fun1,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    return 0;
}

上述代码会产生临界资源竞争，pthread线程引入互斥锁来解决临界资源访问。通过对临界资源加锁来保护资源只能被单个线程操作，操作结束后解锁，其余线程才可获得操作权。

互斥锁API

初始化互斥量

image-20230610204449194

互斥量加锁/解锁

image-20230610204601991

互斥量加锁（非阻塞方式）

image-20230610204828330

互斥量解锁（非阻塞方式）

image-20230610205052585

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

pthread_mutex_t mutex;

int Num = 0;

void *fun1(void *arg)
{
   
   
    pthread_mutex_lock(&mutex);    //加锁
    while(Num < 3){
   
   
        Num++;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);    //解锁
    pthread_exit(NULL);    //退出线程
}

void *fun2(void *arg)
{
   
   
    pthread_mutex_lock(&mutex);    //加锁
    while(Num > -3){
   
   
        Num--;
        printf("%s:Num = %d\n",__FUNCTION__,Num);
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);        //解锁
    pthread_exit(NULL);    //退出线程
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2;
    ret = pthread_mutex_init(&mutex,NULL);    //初始化互斥量
    if(ret != 0){
   
   
        perror("pthread_mutex_init");
        return -1;
    }
    ret = pthread_create(&tid1,NULL,fun1,NULL);    //创建线程
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);    //创建线程
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);    //等待线程结束
    pthread_join(tid2,NULL);    //等待线程结束
    pthread_mutex_destroy(&mutex);    //销毁互斥量
    return 0;
}
//输出结果如下：

image-20230610205945019

上面代码加入互斥量，保证临界变量在某一时刻只能被某一线程控制，实现了对临界资源的控制。

线程加锁在循环内和循环外的情况：

对于单核机器，执行结果没有区别。当多核机器执行代码时候，可能会发生“抢锁现象”，取决于操作系统底层的实现。

多线程执行顺序控制

信号量：解决线程执行顺序

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void *fun1(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

void *fun3(void *arg)
{
   
   
    printf("%s:Pthread Come!\n",__FUNCTION__);
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2,tid3;
    ret = pthread_create(&tid1,NULL,fun1,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid3,NULL,fun3,NULL);
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    return 0;
}

image-20230610210656769

当多次执行该函数次序是无序的，线程之间的竞争无法控制，使用信号量使得线程顺序可控

信号量API简述

互斥量用来防止多个线程同时访问某个临界资源

信号量起通知作用，线程A在等待某事，线程B完成这件事后就可以发信号给线程A

初始化信号量

image-20230610211339351

信号量P/V操作

image-20230610211411655

信号量申请（非阻塞方式）

image-20230610211535236

与上面的sem_wait一致，区别在于此函数非阻塞

信号量销毁

image-20230610211620935

程序实例

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <semaphore.h>

sem_t sem1,sem2,sem3;//申请的三个信号量变量

void *fun1(void *arg)
{
   
   
    sem_wait(&sem1);//因sem1本身有资源，所以不被阻塞 获取后sem1-1 下次会会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem2);// 使得sem2获取到资源
    pthread_exit(NULL);
}

void *fun2(void *arg)
{
   
   
    sem_wait(&sem2);//因sem2在初始化时无资源会被阻塞，直至14行代码执行 不被阻塞 sem2-1 下次会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem3);// 使得sem3获取到资源
    pthread_exit(NULL);
}

void *fun3(void *arg)
{
   
   
    sem_wait(&sem3);//因sem3在初始化时无资源会被阻塞，直至22行代码执行 不被阻塞 sem3-1 下次会阻塞
    printf("%s:Pthread Come!\n",__FUNCTION__);
    sem_post(&sem1);// 使得sem1获取到资源
    pthread_exit(NULL);
}

int main()
{
   
   
    int ret;
    pthread_t tid1,tid2,tid3;
    ret = sem_init(&sem1,0,1);  //初始化信号量1 并且赋予其资源
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = sem_init(&sem2,0,0); //初始化信号量2 让其阻塞
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = sem_init(&sem3,0,0); //初始化信号3 让其阻塞
    if(ret < 0){
   
   
        perror("sem_init");
        return -1;
    }
    ret = pthread_create(&tid1,NULL,fun1,NULL);//创建线程1
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid2,NULL,fun2,NULL);//创建线程2
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    ret = pthread_create(&tid3,NULL,fun3,NULL);//创建线程3
    if(ret != 0){
   
   
        perror("pthread_create");
        return -1;
    }
    /*回收线程资源*/
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);

    /*销毁信号量*/
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);

    return 0;
}

image-20230610212006787

加入信号量使得线程执行顺序变为可控的

线程处理函数中，每个线程通过sem_wait函数来等待资源，发生阻塞。信号量1初始值有资源，可以执行线程1的逻辑。执行完sem_wait函数后会导致sem1-1使得下一次该线程被阻塞（为啥？看上面解释变成0了？）

条件变量（同步机制）

用来通知其他线程条件满足了，一般用来通知对方共享数据的状态信息，条件变量结合互斥量来使用。

创建和销毁条件变量

image-20230610212815405

等待条件变量

image-20230610212845985

通知条件变量

image-20230610212914644

ps -T #查看进程信息
kill -9 进程号 #停止对应进程号进程

总结

image-20230610215213761

image-20230610215241866

image-20230610215309038

image-20230610215329413

image-20230610215349268

文章标签：
API
关键词：
线程编程
王先森Vicent
目录
相关文章
游客762btuqu5wybw666
|
3天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
11 3
叫个什么名字
|
12天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
50 5
ShaFaChuang-36210
|
9天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
24 1
请看我回答~
|
12天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中，多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程，以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发，逐步探索线程池的高效使用，并讨论常见的多线程问题。无论你是Java新手还是希望深化理解，这篇文章都将为你打开多线程的大门。
请看我回答~
29 1
潇洒洒
|
20天前
|
安全 程序员 API
Pthread深度解析：掌握多线程编程的核心工具
【10月更文挑战第19天】
潇洒洒
49 10
萝卜带泥
|
13天前
|
安全 Java 编译器
Java多线程编程的陷阱与最佳实践####
【10月更文挑战第29天】 本文深入探讨了Java多线程编程中的常见陷阱，如竞态条件、死锁、内存一致性错误等，并通过实例分析揭示了这些陷阱的成因。同时，文章也分享了一系列最佳实践，包括使用volatile关键字、原子类、线程安全集合以及并发框架（如java.util.concurrent包下的工具类），帮助开发者有效避免多线程编程中的问题，提升应用的稳定性和性能。 ####
萝卜带泥
40 1
叫个什么名字
|
16天前
|
存储 设计模式 分布式计算
Java中的多线程编程：并发与并行的深度解析####
在当今软件开发领域，多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制，从基础概念到高级应用，全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述，本文旨在通过详尽的技术剖析，为读者构建一个系统化的多线程知识框架，辅以生动实例，让抽象概念具体化，复杂问题简单化。 ####
叫个什么名字
59 4
东方睿赢
|
17天前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
44 4
丰宝宝
|
17天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域，多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践，通过实际案例分析，帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结，本文将结合作者多年的实践经验，以故事化的方式讲述多线程编程的魅力与挑战，旨在为读者提供一种全新的学习视角。
丰宝宝
45 3
shuj
|
18天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中，多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手，他们各自演奏着自己的部分，却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界，让你从零基础到能够编写基本的多线程程序。
shuj
30 1