CodeBlanks Logo Icon CodeBlanks
Login Register

GIL

Learn the GIL (Global Interpreter Lock) concept.

What is the GIL?

The GIL (Global Interpreter Lock) is a lock in CPython that ensures only one thread executes Python bytecode at a time. This means threading does not speed up CPU-bound work.

For I/O-bound work (network, files) the GIL is released; so threading is still useful there. But for pure computation threads run sequentially; there is no parallelism. To parallelize CPU-bound work you use multiprocessing; each process has its own GIL.

Effect of the GIL

The GIL is not a problem for I/O-bound work. When a thread does time.sleep() or a network request it releases the GIL; other threads can run.

But a CPU-bound loop (such as for i in range(1000000): pass) holds the GIL continuously. Other threads wait during this time. So two CPU-bound threads run as fast as a single thread; there is no parallelism gain. If you need true parallel CPU power multiprocessing is the only option.

Practice CPU-bound work under the GIL

Import with from threading import Thread. Define a count function that increments total in a for i in range(1000): loop and does print("bitti"). Create a thread with Thread(target=count), call .start() and .join().

Starter code

main.py
# write the count function
# create and run a thread

Sample solution

main.py
from threading import Thread

def count():
    total = 0
    for i in range(1000):
        total += 1
    print("done")

t = Thread(target=count)
t.start()
t.join()

Expected output

bitti

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 Complete the GIL abbreviation

Question 
GIL: Global ____ Lock
Answer 
GIL: Global Interpreter Lock

Explanation: GIL = Global Interpreter Lock.

2 Match GIL concepts

Term Meaning
GIL Global Interpreter Lock
CPU-bound No parallelism
I/O-bound GIL released
multiprocessing Own GIL

3 What is used to parallelize CPU-bound work?

  • threading
  • Lock
  • multiprocessing Correct answer
  • asyncio

Explanation: multiprocessing gives each process its own GIL; CPU work parallelizes.

All lessons in Expert

1 Metaprogramming

  1. type()
  2. Metaclass
  3. __init_subclass__
  4. __class_getitem__
  5. Decorate class
  6. Summary - Metaprogramming

2 Descriptors

  1. Descriptor protocol
  2. Data descriptor
  3. Non-data descriptor
  4. @property
  5. __set_name__
  6. Summary - Descriptors

3 AST

  1. ast.parse
  2. ast.walk
  3. NodeVisitor
  4. NodeTransformer
  5. compile
  6. Summary - AST

4 ctypes and CFFI

  1. ctypes.CDLL
  2. ctypes types
  3. argtypes and restype
  4. cffi
  5. Structure
  6. Summary - ctypes and CFFI

5 Multiprocessing

  1. Process
  2. start and join
  3. Queue
  4. Pool
  5. Manager
  6. Summary - Multiprocessing

6 Threading and asyncio

  1. threading.Thread
  2. Lock
  3. GIL
  4. concurrent.futures
  5. asyncio vs threading
  6. Summary - Threading and asyncio

7 Performance

  1. timeit
  2. cProfile
  3. sys.getsizeof
  4. slots and tuple
  5. numpy vectorization
  6. Summary - Performance

8 Expert final

  1. Project design
  2. Metaprogramming
  3. Multiprocessing
  4. ctypes
  5. Putting it together