1.线程安全

1. 线程安全概念： 线程安全概念：当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。
2.  synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"
3. "
4.  
5. public class MyThread extends Thread{
6.   
7.    private int count = 5 ;
8.   
9.    //synchronized加锁
10.    public  void run(){
11.       count--;
12.       System.out.println(this.currentThread().getName() + " count = "+ count);
13.    }
14.   
15.    public static void main(String[] args) {
16.      
17.       MyThread myThread = new MyThread();
18.       Thread t1 = new Thread(myThread,"t1");
19.       Thread t2 = new Thread(myThread,"t2");
20.       Thread t3 = new Thread(myThread,"t3");
21.       Thread t4 = new Thread(myThread,"t4");
22.       Thread t5 = new Thread(myThread,"t5");
23.       t1.start();
24.       t2.start();
25.       t3.start();
26.       t4.start();
27.       t5.start();
28.    }
29. }
30.  
31. 当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），
32. 一个线程想要执行synchronized修饰的方法里的代码：
33.     1 尝试获得锁
34.     2 如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）
35. 输出结果：
36. t1 count = 2
37. t4 count = 0
38. t5 count = 1
39. t3 count = 2
40. t2 count = 2
41.  
42.  
43. public class MyThread extends Thread{
44.   
45.    private int count = 5 ;
46.   
47.    在方法上加了synchronized
48.    public synchronized void run(){
49.       count--;
50.       System.out.println(this.currentThread().getName() + " count = "+ count);
51.    }
52.   
53.    public static void main(String[] args) {
54.      
55.       MyThread myThread = new MyThread();
56.       Thread t1 = new Thread(myThread,"t1");
57.       Thread t2 = new Thread(myThread,"t2");
58.       Thread t3 = new Thread(myThread,"t3");
59.       Thread t4 = new Thread(myThread,"t4");
60.       Thread t5 = new Thread(myThread,"t5");
61.       t1.start();
62.       t2.start();
63.       t3.start();
64.       t4.start();
65.       t5.start();
66.    }
67. }
68.  
69. 输出结果：
70. t2 count = 4
71. t5 count = 3
72. t3 count = 2
73. t1 count = 1
74. t4 count = 0
75.