每天一例多线程[day1]-----synchronized与锁竞争

[javascript] view plain copy

1. <code class="language-java">/** 
2.  * 多个线程一把锁 
3.  *  
4.  * 线程安全概念： 
5.  * <span>  </span>     当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为， 
6.  * 那么这个类（对象或方法）就是线程安全的。 
7.  *  
8.  * synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区" 
9.  *  
10.  *  
11.  * 描述：观察MyThread类的run方法上加锁synchronized和不加锁打印有何区别。 
12.  *  
13.  * @author jeff 
14.  * 
15.  */  
16. </code>  

public class MyThread extends Thread{	

1. private int count = 5 ;

2.  

3. public void run(){

4. count--;

5. System.out.println(Thread.currentThread().getName() + " count = "+ count);

6. }

7.  

8. public static void main(String[] args) {

9.  

10. MyThread myThread = new MyThread();

11. Thread t1 = new Thread(myThread,"t1");

12. Thread t2 = new Thread(myThread,"t2");

13. Thread t3 = new Thread(myThread,"t3");

14. Thread t4 = new Thread(myThread,"t4");

15. Thread t5 = new Thread(myThread,"t5");

16. t1.start();

17. t2.start();

18. t3.start();

19. t4.start();

20. t5.start();

21. }

22. }

创建t1到t5多个线程，执行MyThread的run方法，如果run方法不加synchronized关键词，结果如下：

1. t1 count = 2

2. t5 count = 1

3. t3 count = 2

4. t2 count = 1

5. t4 count = 0

而与我们预期的结果43210不一致。当我们给run方法加上synchronized关键词，结果如下：

1. t3 count = 4

2. t1 count = 3

3. t4 count = 2

4. t5 count = 1

5. t2 count = 0

也就是说，多个线程访问同一个对象的run方法得到了同步对象锁的控制。

分析：当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），
一个线程想要执行synchronized修饰的方法里的代码：
  1 尝试获得锁

  2 如果拿到锁，执行synchronized代码体内容；

             拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）

        
  3  锁竞争问题：多个线程抢占一把锁会导致CPU消耗严重，导致程序变慢或宕机。
  
所以，我们的程序设计避免出现多线程的锁竞争，减少系统开销。