I miss the normal indicators of a coding tutorial though: fan noises, poor quality audio, and a thick accent that makes learning nearly impossible

Agreed! They overcomplicate the concepts and explain too much right away

Happy to hear that! :)

facts, im actually thinking im junior developer now lol

+1

Legit I had discovered this channel when he'd just posted his videos on python, and i saw how structured and complete his content was, and I knew at that time this channel deserved more followers, but I had nothing to do with python at that point. 2 years later, Here I am, doing a 6 month internship on Python, and i come to youtube to learn about Threading in python, and I land on this video.

The way i understand it is that multiprocessing is just using more than 1 cpu core to do the task at hand. Multithreading would then be using a single core to do 2 or more operations "at once" by hopping back and forth between 2 or more tasks. Btw im fairly new to programming so i might be incorrect. If anyone can confirm please comment or something

​​@@BAMBAMBAMBAMBAMvalyour're right

@@BAMBAMBAMBAMBAMval Hey, so this isn't quite true. Python can be quite a bit different from other languages and adhere to its own way of doing things sometimes, so as someone new to programming, you're probably getting a few misconceptions. Multiprocessing and multithreading are both ways of implementing "concurrency". "Concurrency" encompasses both real parallelism and the simulated "hopping back and forth" between different tasks. Multiprocessing differs from multithreading because it spawns an entire new child process through a process called "forking". You need to know what processes are to really get this, so essentially a process is like a miniature computer system; it has its own CPU registers, its own memory address space, its own PC counter, etc etc. It is like a little miniature box that was developed decades ago as a way to allow one computer to run multiple programs at the same time. A child process contains a copy of every variable, every object, etc in the parent process at the time that it was forked. These two processes now run at the same time. On a single-core machine, the CPU would be bouncing around doing tasks for both processes at the same time. On a multi-core machine, sometimes the two processes would literally, physically be running at the same time on different physical cores that the CPU has. In practice, this is called "multiplexing" and it is the job of the operating system and the CPU scheduling hardware to adequately schedule the hundreds of different processes that run on a computer. There are a few stages that a process can live in: "new", "ready", "running", "waiting", and "terminated" (this depends on your OS as well, I am talking about Unix operating systems mostly). Threads are a lighter-weight way of implementing concurrency. Threads do not have their own address space the same that processes do, and they do not make copies of any variables. Threads are essentially just there to execute instructions and operate on the same data that already exists in the main process. Because of that, it is very important to synchronize threads and make sure that when they are interacting with data, they avoid creating situations called race conditions. As a programmer, you need to implement/use things like locks, mutexes (mutual exclusions), and semaphores to make sure that data is accessed in the correct way. With all that being said, threads also give concurrency, which may be real parallelism or maybe "fake" parallelism achieved through time multiplexing. Threads live on different levels of the operating system too. Some are user threads, like the ones in Python. Others are kernel level threads, which have permission to interact directly with the hardware. And of course there are hardware threads, which are the 4 cores, 8 cores, 16 cores, etc that you have on your CPU. If your computer has 16 cores and is running more than 16 processes and threads, then it is 100% doing some level of time multiplexing. It is impossible to not do that. But there are always at least 16 processes/threads that are truly executing in parallel, unless you write some code that stalls them. I know that was a lot, and there is lot of nuance that I missed so for anyone that reads who knows better I apologize lol Just wanted to give a quick rundown of the differences, similarities, and how you really need to get to the hardware and operating system level of things to understand what is going on. Python abstracts all of that away which makes it difficult to see.

@@TheEpicPineapple56 hey thanks for taking the time to explain all that

Is there a language that's like python (as similar as possible) but also supports true multi threading?

@@-_Nuke_-you could look into Scala

Python 3.13 will have an experimental mode with the GIL deactivated, stay tuned :)

oh I'm using jupyter notebook to run the code

hyperpush the thread

Use multiprocessing and extra hardware