深入理解多线程

最新推荐文章于 2022-06-15 20:24:09 发布
最新推荐文章于 2022-06-15 20:24:09 发布
阅读量1.2k 收藏 4
点赞数 9
分类专栏： Linux 文章标签： Linux Linux互斥量 线程安全 可重入 互斥量的原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56044032/article/details/124745371
版权

文章目录

前言

前面我们已经学习了多线程的基本概念，在深入了解多线程之前也可以回顾一下---->初始多线程

1、线程退出

线程退出都会有两种情况：

  1. 主线程没有等待新线程结束而提前退出，则整个进程退出，但新线程也是一个执行流，此时就可能会造成内存泄漏
void* thread_run(void* args)
{
	const char* ch = (const char*)args;
	while(1)
	{
		printf("我是%s, pid: %d, ID: %p", ch, getpid(), pthread_self());
		sleep(1);
	}
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void*)"新 pthread");

	printf("我是主pthread, pid: %d, ID:%p\n",getpid(), pthread_self());
	sleep(1);
	return 0;
}

主线程创建了一个新线程，新线程进入死循环，而主线程退出，进程也会随着主线程退出而退出
在这里插入图片描述

  • 新线程退出而主线程不退出。主线程继续执行
void *thread_run(void *args)
{
	const char *ch = (const char *)args;

	printf("我是%s, pid: %d, ID: %p\n", ch, getpid(), pthread_self());
	sleep(1);
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void *)"新 pthread");

	//父进程一直死循环
	while (1)
	{
		printf("我是主pthread, pid: %d, ID:%p\n", getpid(), pthread_self());
		sleep(1);
	}
	return 0;
}

在这里插入图片描述
新线程的退出并没有导致整个进程的退出。主线程还是在一直执行。

线程正常退出的结果也有两种：
1.结果正常
2.结果不正常

新进程异常不会被主线程不知道，因为异常是进程级别的，如果一个线程异常就会导致整个进程异常，最终的结果可能导致进程崩溃

2、线程等待

  • 为什么需要线程等待？

因为和进程一样，新线程创建出来就是用来分摊主线程的工作的，主线程需要知道新线程是否完成了工作，完成的工作怎么样了

在这里插入图片描述
参数：
thread: 线程ID
retval: 输出型参数，获取线程的返回值
返回值: 成功返回0；失败返回错误码。

调用该函数的线程将挂起等待,直到id为thread的线程终止

void *thread_run(void *args)
{
	const char *ch = (const char *)args;

	printf("我是%s, pid: %d, ID: %p\n", ch, getpid(), pthread_self());
	sleep(5);
	return (void*)"我是返回值";
}

int main()
{
	pthread_t tid;
	void* ret;
	pthread_create(&tid, NULL, thread_run, (void *)"新 pthread");


	printf("我是主pthread, pid: %d, ID:%p\n", getpid(), pthread_self());
	pthread_join(tid, &ret);
	printf("%s\n", (char*)ret);
	return 0;
}

在这里插入图片描述
新线程的返回值可以是任意数据类型或者对象的地址，但是前提是不能是临时数据

3、线程终止

  • 如果只需要终止某个线程，而不终止进程的方法有3种:
  1. 函数中的return(a.main函数退出return的时候代表(主线程和进程的退出) b.其他线程函数return，只代表当前线程的退出)
  2. 线程可以调用pthread_exit函数终止自己
  3. 一个线程可以代用pthread_ cancel函数去终止同一进程中的另一个线程，主线程可以终止新线程，新线程也可以终止主线程(不推荐这样做)

使用return终止线程

void* thread_run(void* args)
{
	const char* ch = (const char*)args;
	printf("我是%s\n",ch);
	return 123;
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void*)"new thread");
	void* status = NULL;
	pthread_join(tid, &status);
	printf("新线程的退出信息: %d\n", (int)status);
	return 0;
}

在这里插入图片描述

使用pthread_exit函数终止线程
在这里插入图片描述
参数:
retval：不能是一个局部变量或者临时变量
无论在线程的哪个位置调用该函数都会终止该线程，和return一样
只需要将return 123改为 *pthread_exit((void)123)**即可

在这里插入图片描述
线程中能不能使用exit函数终止线程？
答案是不能的，因为eixt是终止进程的，无论在哪个线程调用exit函数都会终止整个线程

void* thread_run(void* args)
{
	const char* ch = (const char*)args;
	printf("我是%s\n",ch);
	sleep(2);
	exit(12);
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void*)"new thread");
	void* status = NULL;
	pthread_join(tid, &status);
	printf("新线程的退出信息: %d\n", (int)status);
	sleep(5);
	return 0;
}

在这里插入图片描述
通过验证可以发现，在线程内调用exit是直接终止进程的，通过echo $? 查看退出码为12，和exit的参数是一致的

使用pthread_ cancel取消目标线程
不建议新进程取消主线程，因为会产生类似僵尸进程的危害
在这里插入图片描述
参数:
thread:线程ID
返回值:成功返回0，失败返回错误码

void* thread_run(void* args)
{
	const char* ch = (const char*)args;
	while(1)
	{
		printf("我是%s\n", ch);
		sleep(1);
	}
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void*)"new thread");
	printf("wait sub thread...\n");
	sleep(3);

	printf("cancel sub thread..\n");
	pthread_cancel(tid);
	sleep(2);
	void* status = NULL;
	pthread_join(tid, &status);
	printf("新线程的退出信息: %d\n", (int)status);
	sleep(3);
	return 0;
}

在这里插入图片描述
主线程通过调用pthread_cancel确实将新线程终止了。
为什么被pthread_cancel()退出以后退出码是-1呢?

答：用pthreat_cancel()函数退出别的别线程以后，该线程是被异常终止掉的，value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED。该函数是一个宏定义。就是-1。
在这里插入图片描述

thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:

  • 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值
  • 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED
  • 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数
  • 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参

4、线程分离

  • 当不需要关心某个线程执行结果如何，或者执行的对与错，就可将这个线程进行分离。线程分离带来的最直观的感受就是主线程不需要关心这个线程的执行如何，线程分离之后不需要被join，运行完毕后，会自动释放Zpcb(类似sigsignal(SIGCHLD, SIG_IGN))
  1. 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏
  2. 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源
  3. 线程组内其他线程对目标线程进行分离，也可以是线程自己分离

分离其他线程:

int pthread_detach(pthread_t thread);

分离自己:

pthread_detach(pthread_self());

主线程调用pthread_detach(pthread_t thread)分离新线程

void *thread_run(void *args)
{
	const char *ch = (const char *)args;
	while (1)
	{
		printf("我是%s\n", ch);
		sleep(1);
	}
	return (void *)123;
}

int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, thread_run, (void *)"new thread");

	sleep(3);
	//进行线程分离
	printf("thread_dedach begin\n");
	pthread_detach(tid);

	void *status = NULL;
	int ret = pthread_join(tid, &status);
	printf("join的返回值: %d,新线程的退出信息: %d\n", ret, (int)status);
	return 0;
}

在这里插入图片描述
运行代码，我们发现join的返回值为22，不是0，说明join是失败的。而status也没有拿到新线程的退出结果。
所以一个线程被设置分离之后，一定不能再join了，因为一定会失败的

小总结：

  • 线程分离退出码是0，而不是线程返回的退出码，是因为将线程分离以后，拿不到线程的退出码，也不需要拿到它的退出码
  • 线程分离以后，被分离的线程会自动释放自己的资源。不需要被等待，退出码也不会写进PCB
  • 但是线程被分离以后，如果线程中有异常，还是会影响当前进程

5、线程互斥

5.1 线程间的互斥相关背景概念

  • 临界资源: 多线程执行流共享的资源就叫做临界资源(多线程，多进程打印数据到显示器【临界资源】)
  • 临界区: 每个线程内部，访问临界资源的代码，就叫做临界区
  • 互斥: 任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
  • 同步: 一般而言，让访问临界资源的过程在安全的前提下(一般都是互斥和原子性的)，让访问资源具有一定的顺序性
  • 原子性: 不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

在这里插入图片描述

5.2 互斥量mutex

  • 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量
  • 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互
  • 多个线程并发的操作共享变量，会带来一些问题

例如下面的购票例子就有很大的问题

#define NUM 5
int tickets = 100;//临界资源

void *ThreadRoutine(void *args)
{
    int id = *(int *)args;
    delete (int *)args;

    while (true)
    {
        if (tickets > 0)
        {
            usleep(1000);
            cout << "我是[" << id << "] 我要抢的票是: " << tickets << endl;
            tickets--;
        }
        else
            //没有票了
            break;
    }
}

int main()
{
    pthread_t tid[NUM];
    for (int i = 0; i < NUM; ++i)
    {
        int *id = new int(i);
        pthread_create(&tid[i], nullptr, ThreadRoutine, (void *)id);
    }

    for (int i = 0; i < NUM; ++i)
    {
        pthread_join(tid[i], nullptr);
    }
    return 0;
}

在这里插入图片描述

一共有5个线程会去抢100张票，按常理来说当100票都被抢完了，就没有票抢了，但是结果却不是这样。因为tickets是全局变量，没有进行加锁，所以它不是安全的

要解决以上问题，需要做到三点:

  1. 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
  2. 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
  3. 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量

在这里插入图片描述

5.3 互斥量的接口

初始化互斥量：

  • 初始化互斥量有两种方法：
  1. 静态分配

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

  1. 动态分配

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t
*restrict attr);

参数:

  • mutex：要初始化的互斥量
  • attr：NULL

销毁互斥量：

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

参数:

  • mutex：需要销毁的互斥量

销毁互斥量需要注意：

  • 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁
  • 不要销毁一个已经加锁的互斥量
  • 已经销毁的互斥量，要确保后面不会有线程再尝试加锁

互斥量加锁和解锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数:

  1. mutex：要初始化的互斥量

返回值:

  • 成功返回0,失败返回错误号

调用 pthread_ lock 时，可能会遇到以下情况:

  1. 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
  2. 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁

5.4 通过加锁改进购票系统

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using namespace std;

#define NUM 5

class Ticket
{
private:
    int tickets;
    pthread_mutex_t mtx;

public:
    Ticket()
        : tickets(100)
    {
    	//初始化锁
        pthread_mutex_init(&mtx, nullptr);
    }

    bool GetTicket()
    {
        bool res = true;
        //抢票时需要加锁
        pthread_mutex_lock(&mtx);
        //执行这部分代码的执行流式互斥的，是串行执行的！
        if (tickets > 0)
        {
            usleep(1000); // 1s = 1000ms  1ms = us
            cout << "我是[" << (long long)pthread_self() << "] 我要抢的票是: " << tickets << endl;
            tickets--;
        }
        else
        {
            res = false;
            printf("票已经被抢空了\n");
        }
        //不抢票时，需要解锁
        pthread_mutex_unlock(&mtx);
        return res;
    }

    ~Ticket()
    {
    	//销毁锁
        pthread_mutex_destroy(&mtx);
    }
};

void *ThreadRoutine(void *args)
{
    Ticket *t = (Ticket *)args;
    while (true)
    {
        if (!t->GetTicket())
            break;
    }
}

int main()
{
    Ticket *t = new Ticket();
    pthread_t tid[NUM];
    for (int i = 0; i < NUM; ++i)
    {
        pthread_create(&tid[i], nullptr, ThreadRoutine, (void *)t);
    }
	
    for (int i = 0; i < NUM; ++i)
    {
        pthread_join(tid[i], nullptr);
    }
    return 0;
}

在这里插入图片描述

5.5 互斥量实现原理

  • 经过上面的例子,如果不是原子的，有可能会有数据出现问题
  • 为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期

在这里插入图片描述

6、互斥量总结

  1. 对临界区进行保护，所有的执行线程都必须遵守这个规则。
  2. 基本过程：lock->访问临界区->unlock。
  3. 所有的线程必须先看到同一把锁，锁本身就是临界资源!锁本身得先保证自身安全！申请锁的过程，不能有中间状态，也就是两态的，lock->原子性，unlock->原子性。
  4. lock->访问临界区（花时间）->unlock,在特定线程/进程拥有锁的时候，期间有新线程过来申请锁，一定不能申请到，那么新线程进行阻塞，将进程，线程对应的PCB投入到等待队列。
  5. 加锁时候效率变低，本来是并行/并发执行流，加锁以后成了串行执行流。
  6. 一次保证只有一个线程进入临界区，访问临界资源，就叫做互斥。

7、可重入和线程安全

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数

7.1 常见的线程不安全的情况

  1. 不保护共享变量的函数
  2. 函数状态随着被调用，状态发生变化的函数
  3. 返回指向静态变量指针的函数
  4. 调用线程不安全函数的函数

7.2 常见的线程安全的情况

  1. 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
  2. 类或者接口对于线程来说都是原子操作
  3. 多个线程之间的切换不会导致该接口的执行结果存在二义性

7.3 常见不可重入的情况

  1. 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
  2. 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构
  3. 可重入函数体内使用了静态的数据结构

7.4 常见可重入的情况

  1. 不使用全局变量或静态变量
  2. 不使用用malloc或者new开辟出的空间
  3. 不调用不可重入函数
  4. 不返回静态或全局数据，所有数据都有函数的调用者提供
  5. 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

7.5 可重入与线程安全联系

  1. 函数是可重入的，那就是线程安全的
  2. 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题
  3. 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的

7.6 可重入与线程安全区别

  1. 可重入函数是线程安全函数的一种
  2. 线程安全不一定是可重入的，而可重入函数则一定是线程安全的
  3. 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的
你好，冯同学
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
深入理解Python 多线程
12-17
Python里的多线程是假的多线程，不管有多少核，同一时间只能在一个核中进行操作！利用Python的多线程，只是利用CPU上下文切换的优势，看上去像是并发，其实只是个单线程，所以说他是假的单线程。 那么什么时候用多...
深入了解c#多线程编程
08-18
深入了解C#多线程编程 一、使用线程的理由 在C#多线程编程中，使用线程可以将代码同其他代码隔离，提高应用程序的可靠性，可以使用线程来简化编码，实现并发执行。 二、基本知识 1. 进程与线程：进程作为操作...
c# 多线程（三）
weixin_40715466的博客
03-18 888
ThreadPoolNetFramework2.0 Thread--功能繁多，反而用不好--就像给4岁小孩一把热武器，反而会造成更大的伤害,不好管理，对线程数量是没有管控的线程池. 如果某个对象创建和销毁代价比较高，同时这个对象还可以反复使用的，就需要一个池子 保存多个这样的对象，需要用的时候从池子里面获取；用完之后不用销毁，放回池子；(享元模式) 节约资源提升性能；此外，还能管控总数量，...
C#Thread(二)
weixin_49758946的博客
06-15 684
线程中独立的资源包括:线程中共享的资源包括:线程中数据的独立与共享独立:CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保存独立共享:如果多个线程都引用到同一个对象的实例.那么它们就共享了数据被Lambda表达式或匿名函数所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享静态字段(field)也会在线程间共享数据 如果你想往线程的启动方法里传递参数,最简单的方式师使用lambda表达式,在里面使用参数调用方法.例 这里是用顶级语句写的控制台输出的结果如下:......
c#-线程池
xie__jin__cheng的博客
07-10 282
c#-线程池 using System; using System.Threading; namespace ConsoleApp15 { class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); ...
讲给女朋友听的java多线程（2万字深入理解多线程，有实例代码辅助理解）
01-20
读完本文大概需要30分钟左右，本文有大量的实例代码和典型例题帮助大家理解java多线程。虽然多线程比较难以理解，仅靠一篇文章恐怕搞不定。但读完本文最起码能让你搞懂java多线程的70%以上，至于熟练运用，还是得...
Android开发笔记之:深入理解多线程AsyncTask
01-20
Understanding AsyncTaskAsyncTask是Android 1.5 Cubake加入的用于实现异步操作的一个类，在此之前只能用Java SE库中的Thread来实现多线程异步，AsyncTask是Android平台自己的异步工具，融入了Android平台的特性，让...
深入理解Netty线程模型
02-24
从这篇文章中，大家可以学习到如下知识：什么是I/O多路复用Reactor三种线程模型Netty线程模型NioEventLoop源码分析JDKepollbug学习I/O多路复用之前，我们先来了解如下几个概念：阻塞I/O：客户端从socket中读取数据或...
C#线程池ThreadPool
u014511737的专栏
08-12 1万+
相关概念：     线程池可以看做容纳线程的容器；     一个应用程序最多只能有一个线程池；     ThreadPool静态类通过QueueUserWorkItem()方法将工作函数排入线程池；     每排入一个工作函数，就相当于请求创建一个线程；   线程池的作用： 线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了
c#清除所有线程
萨摩耶的微笑
06-23 2492
今天在关闭程序的时候，出现了一场，同线程无法关闭的问题，截图以后补上，下面是解决方法 this.Close(); Application.Exit()； Application.ExitThread(); System.Environment.Exit(0); 一共有四种方式 this.Close()：关闭当前窗口 Application.Exit()：强制所有消息中止，退出所有的窗...
C# 多线程的自动管理(线程池)
weixin_33698823的博客
04-01 325
在多线程的程序中，经常会出现两种情况：    1. 应用程序中线程把大部分的时间花费在等待状态，等待某个事件发生，然后给予响应。这一般使用 ThreadPool（线程池）来解决。     2. 线程平时都处于休眠状态，只是周期性地被唤醒。这一般使用 Timer（定时器）来解决。 ThreadPool 类提供一个由系统维护的线程池（可以看作一个线程的容器），该容器需要 Windows 2000 以...
C# 资源释放
MK的专栏
03-26 846
终于开始动手写这篇文章了，有个网友催了我好几次，今天终于可以静下心来完成它。 便于对文章的开展，需要先明确两个概念。第一个就是很多人用.Net写程序，会谈到托管这个概念。那么.Net所指的资源托管到底是什么意思，是相对于所有资源，还是只限于某一方面资源？很多人对此不是很了解，其实.Net所指的托管只是针对内存这一个方面，并不是对于所有的资源；因此对于Stream，数据库的连接，GDI+
C# 多线程学习（六）线程池（ThreadPool）——线程资源的复用和自动管理
我的大学
07-06 9080
什么是线程池大家都知道，我们在打开一个应用的时候，操作系统是要做很多的事情的，动态链接、装载、分配虚拟空间、等等等等，其实一个应用的打开同时也伴随着一个进程的建立。进程的建立是需要时间的，在进程上开线程也是需要消耗CPU时间,操作系统需要分配给新开的线程地址空间、栈空间、寄存器等，在线程结束的时候，操作系统又将这些东西回收（着同样需要消耗时间）。所以我们在多线程的处理中如果遇到要很多次地开启线程去处
C#多线程中子线程快速终止的几个处理办法
热门推荐
EffectiveAgui的专栏
08-08 2万+
因项目需要，采用了多线程方案，其中主线程负责界面处理（如显示数据、与用户交互等），子线程负责读写串口（发送命令、读取数据）。但是，由于使用多线程的经验较少，对于关闭子线程的问题上走了一些弯路，在此留文纪念，希望能帮助遇到此问题的朋友。          版本1：         在客户关闭程序时，主线程直接关闭，不考虑子线程。        问题：任务管理器中，主程序进程还在运行（在等子线程
简单说说Delphi中线程的释放
youthon的专栏
08-26 1万+
线程的释放方式有两种：一种是线程在运行完成后自动释放，一种是手动释放。 无论是那种释放，都应该在线程停止后进行释放。 然而线程的停止也有两种情况：一种是不需要设置标志位，直接完成；一种是由于execute方法中做了循环，需要设置标志位才能停止。 如果线程已经停止并且自动释放，再去手动停止，就会报错。 下面看代码： 1、自动停止后自动释放的线程： constructor TT
C#中线程占用内存过大解决方法
diaoquan4385的博客
04-10 1628
项目中用到了多线程,而且是1000线程并发运行,发现内存占用过高,于是对项目里用到的对象逐个测试,发现是线程对象占用内存 Thread[] threads = new Thread[1000]; for(int i = 0; i<threads.Length; i++) { ...
java教学课件：第7章 多线程.ppt
06-18
- 通过学习这个章节，读者将掌握Java中多线程的基本原理和实践技巧，能够创建和管理自己的线程，并理解多线程编程中可能遇到的问题和解决方案。 了解这些知识点后，开发者将能够利用Java的多线程特性编写出更高效...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值