threading多线程的一些疑惑

西殴

这个线程和我想象的线程不一样
我想象的线程 下图：

1. import threading
   
2. 
   
3. def func():
   
4. 
   
5.     print('第二线程      ')
   
6. 
   
7. 
   
8.     print('第二线程第二次    ')
   
9. 
   
10. 
    
11. def funcc():
    
12. 
    
13.     print('第一线程')
    
14. 
    
15. 
    
16.     print('第一线程第二次   ')
    
17.    
    
18. 
    
19. thread1= threading.Thread(target=func)
    
20. thread2= threading.Thread(target=funcc)
    
21. thread1.start()
    
22. thread2.start()
    
23. 
    
24. #执行结果：
    
25. >>> 第二线程      第一线程
    
26. 
    
27. 第二线程第二次    第一线程第二次  
    

复制代码

跟自己写的有什么区别

1. def func():
   
2.     print('第一线程             ',end='')
   
3.     func1()
   
4. 
   
5. def func1():
   
6.     print('第二线程')
   
7.     func2()
   
8. 
   
9. def func2():
   
10.     print('第一线程第二次       ',end='')
    
11.     func3()
    
12. 
    
13. def func3():
    
14.     print('第二线程第二次')
    
15. 
    
16. 
    
17. 
    
18. func()
    
19. 
    
20. #执行结果：
    
21. 第一线程             第二线程
    
22. 第一线程第二次       第二线程第二次
    

复制代码

多线程的执行过程给我的感觉就如 下图：

更形象一点 下图：


线程可以不可以先执行func()里的一段代码 而不是只执行func()里的一条代码就跳到funcc()里执行一跳代码，
再跳回func()里执行一跳代码这样的循环

SixPy

多线程是并行的，不一定谁先谁后

要协调线程之间的先后，可以用 锁

西殴

SixPy 发表于 2017-6-17 23:08
多线程是并行的，不一定谁先谁后

要协调线程之间的先后，可以用 锁

它给我的感觉并没有是并行的   只不过是cpu快而已   CPU快跳来跳去   就以为是它是两个是并行的了？

西殴

SixPy 发表于 2017-6-17 23:08
多线程是并行的，不一定谁先谁后

要协调线程之间的先后，可以用 锁

证明多线程不是并发的

1. import threading
   
2. 
   
3. def fun():
   
4.     while True:
   
5.         print('1 ')
   
6. 
   
7. def func():
   
8.     while True:
   
9.         print('2')
   
10. 
    
11. #lock = threading.Lock()
    
12. thread1= threading.Thread(target=fun())
    
13. thread2= threading.Thread(target=func())
    
14. 
    
15. thread1.start()
    
16. thread2.start()

复制代码

如果是并发的应该是这样的吧

1. 12
   
2. 12
   
3. 12
   
4. 12
   
5. 12
   
6. 12
   
7. ::
   
8. ::
   
9. 12

复制代码