手把手教你做项目多线程篇——基础知识详解(1)

=======================================================================

说这么多不如实际动手练练，首先导入线程

特别注意:大家在见建文件的时候名字千万别和导入的包threading一样不然会出错的。

小知识

---

import threading

让我们先看看自己程序现在有多少个进程

import threading

def main():

print(threading.current_thread())

if name == ‘main’:

main()

结果：1#我的就一个你的呢？

如果你的进程不为一的话还可以这样查看每一个进程名

import threading

def main():

print(threading.active_count())

print(threading.enumerate())

if name == ‘main’:

main()

[<_MainThread(MainThread, started 36004)>]#返回的是一个列表因为我的目前就一个所以就一个主进程

还可以查看正在运行的进程

import threading

def main():

print(threading.active_count())

print(threading.enumerate())

print(threading.current_thread())

if name == ‘main’:

main()

1

[<_MainThread(MainThread, started 36004)>]

<_MainThread(MainThread, started 36004)>

创建一个简单的线程

---

首先我们先介绍一下threading.Thread（）里面的参数，大家学python每个模块的功能时最好还是看一下源文件内容，这样有助于提高你的编程能力：

需要注意的点我已经打上标记了

import threading

def first():

print(“frist active”)

print(“frist finish”)

def main():

first_thread=threading.Thread(target=first,name=“T1”)

first_thread.start()#开始的标志

print(“main”)

if name == ‘main’:

main()

结果：

第一次运行

frist active

main

frist finish

第二次运行

frist active

frist finish

main

每次的结果不一样就已经表明Frist和main是同时运行的了。

如果说效果不太明显的话，我们改进一下接下来我们引入

import time

import threading

import time

def first():

print(“frist active”)

time.sleep(3)

print(“frist finish”)

def main():

first_thread=threading.Thread(target=first,name=“T1”)

first_thread.start()

print(“main”)

if name == ‘main’:

main()

结果：

frist active

main

frist finish

因为执行到Frist active的时候Frist线程要睡3秒这个时候main还在执行所以这样每次都是这个结果了。

特别强调target=first不是导入Frist函数从源文件我们就已经看出是通过run（）方法进行的，这里解释我引用一位大佬解释

链接

这位大佬大家应该都熟悉，就是顶顶大名的雷学委各位大佬可以去他的主页看看可能会学到些新知识雷学委

当然如果你觉得这样不行的话你也可以重写threading.Thresd里的run方法来个自定义线程

class MyThread(threading.Thread):

def init(self,n):

super(MyThread,self).init() #重构run函数必须写

self.n = n

def run(self):

print(‘task’,self.n)

time.sleep(1)

print(‘2s’)

time.sleep(1)

print(‘1s’)

time.sleep(1)

print(‘0s’)

time.sleep(1)

if name == ‘main’:

t1 = MyThread(‘t1’)

t2 = MyThread(‘t2’)

t1.start()

t2.start()

结果：

task t1

task t2

2s

2s

1s

1s

0s

0s

守护线程

---

所谓’线程守护’，就是主线程不管该线程的执行情况，只要是其他子线程结束且主线程执行完毕，主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。

不好理解的话来看看例子

import threading

import time

def first():

print(“frist active”)

time.sleep(3)

print(“frist finish”)

def second():

print(“second active”)

print(“second finish”)

def main():

first_thread=threading.Thread(target=first,name=“T1”)

second_thresd=threading.Thread(target=second,name=“T2”)

first_thread.setDaemon(True)#一定要在start（）前开始

first_thread.start()

second_thresd.start()

print(“main”)

if name == ‘main’:

main()

结果

frist active

second active

second finishjiemeijieshu

main

当主线程和其他子线程都结束不管守护线程first_thread 结没结束程序都结束

当设second_thresd为守护线程的时候情况是这样的

import threading

import time

def first():

print(“frist active”)

time.sleep(3)

print(“frist finish”)

def second():

print(“second active”)

print(“second finish”)

def main():

first_thread=threading.Thread(target=first,name=“T1”)

second_thresd=threading.Thread(target=second,name=“T2”)

second_thresd.setDaemon(True)#一定要在start（）前开始

first_thread.start()

second_thresd.start()

print(“main”)

if name == ‘main’:

main()

frist active

second active

second finish

main

frist finish #尽管输出这个要等三秒

主进程等待子进程结束

---

为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行

import threading

import time

def first():

print(“frist active”)

time.sleep(3)

print(“frist finish”)

def second():

print(“second active”)

print(“second finish”)

def main():

first_thread=threading.Thread(target=first,name=“T1”)

second_thresd=threading.Thread(target=second,name=“T2”)

first_thread.start()

second_thresd.start()

first_thread.join()

print(“main”)

if name == ‘main’:

main()

结果：

frist active

second active

second finish

frist finish

main

不加join是这样的结果

frist active

second active

second finish

main

frist finish

共享全局变量的特性

---

这里定义一个全局变量A

import threading

import time

def first():

global A

print(“frist active”)

time.sleep(3)

A=A+3

print(“frist:%d”%A)

print(“frist finish”)

def second():

global A

print(“second active”)

A=A+6

print(“second:%d”%A)

print(“second finish”)

def main():

global A

first_thread=threading.Thread(target=first,name=“T1”)

second_thresd=threading.Thread(target=second,name=“T2”)

first_thread.start()

second_thresd.start()

#first_thread.join()

print(“main”)

A=A+3

print(“mian:%d”%A)

if name == ‘main’:

A=0

main()

来看一下结果

frist active

second active

second:6

second finish

main

mian:9

frist:12

frist finish

锁

---

由上面的例子可以看出，输出A的值的时候不同进程之间的资源是共享的这就导致了变量A的值不固定造成了脏数据的情况，不理解的话我们就来个例子。

在没有互斥锁的情况下，假设账户有一万元钱，存钱和取钱同时进行可能账户余额会有一万一千元。这样我当然高兴只是银行不答应。为了避免这种情况我们引入锁的概念，下面我们简单的介绍几种编程里面常用的。

互斥锁

import threading

import time

def first():

global A,lock

lock.acquire()

print(“frist active”)

time.sleep(3)

A=A+3

print(“frist:%d”%A)

print(“frist finish”)

lock.release()

def second():

global A,lock

lock.acquire()

print(“second active”)

A=A+6

print(“second:%d”%A)

print(“second finish”)

lock.release

def main():

global A,lock

lock=threading.Lock()

first_thread=threading.Thread(target=first,name=“T1”)

second_thresd=threading.Thread(target=second,name=“T2”)

first_thread.start()

second_thresd.start()

#first_thread.join()

print(“main”)

A=A+3

print(“mian:%d”%A)

if name == ‘main’:

A=0

main()

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结：绘上一张Kakfa架构思维大纲脑图（xmind）

其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？

若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理

梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。

• Kafka入门

• 为什么选择Kafka

• Kafka的安装、管理和配置

• Kafka的集群

• 第一个Kafka程序

• Kafka的生产者

• Kafka的消费者

• 深入理解Kafka

• 可靠的数据传递

• Spring和Kafka的整合

• SpringBoot和Kafka的整合

• Kafka实战之削峰填谷

• 数据管道和流式处理(了解即可)

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
有帮助，可以扫码获取！！（备注Java获取）**

总结：绘上一张Kakfa架构思维大纲脑图（xmind）

[外链图片转存中…(img-KcayAOCl-1713694513108)]

其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？

若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理

梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。

• Kafka入门

• 为什么选择Kafka

• Kafka的安装、管理和配置

• Kafka的集群

• 第一个Kafka程序

• Kafka的生产者

• Kafka的消费者

• 深入理解Kafka

• 可靠的数据传递

• Spring和Kafka的整合

• SpringBoot和Kafka的整合

• Kafka实战之削峰填谷

• 数据管道和流式处理(了解即可)

[外链图片转存中…(img-Iu4SGff7-1713694513109)]

[外链图片转存中…(img-TuEDZ7Uu-1713694513109)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！