严格意义上说，只有操作才有是否安全的定义，因为线程是否安全，针对的不是对象，而是操作。

如果我们指这样的操作L[0] = L[0] + 1，它当然不是一个原子操作，不加以保护就会导致线程不安全，而L.append(i)这样的操作则是线程安全的。

举个list线程不安全的例子

import threading
import time

zero = [3]


def change_zero():
    global zero
    for i in range(3000000):
        # zero += 1
        # zero -= 1
        zero[0] = zero[0] + 1
        zero[0] = zero[0] - 1


th1 = threading.Thread(target=change_zero)
th2 = threading.Thread(target=change_zero)
th1.start()
th2.start()
th1.join()
th2.join()
print(zero)

运行会发现，每次结果不一样，为啥，是因为zero[0] = zero[0] + 1这个操作不是原子性的，分解下来是这样

x = zero[0] + 1
zero[0] = x

有可能赋值给x完后，GIL锁就给了其他线程，此时会产生线程不安全的情况

如何做到线程安全呢？

import threading
import time

zero = [3]
lock = threading.Lock()


def change_zero():
    global zero
    for i in range(3000000):
        # zero += 1
        # zero -= 1
        with lock:
            zero[0] = zero[0] + 1
            zero[0] = zero[0] - 1


th1 = threading.Thread(target=change_zero)
th2 = threading.Thread(target=change_zero)
th1.start()
th2.start()
th1.join()
th2.join()
print(zero)

加上一把锁就行，强行保证了操作的原子性，但是，会降低执行效率