java线程安全与死锁

线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。

出现线程安全问题的根本原因：
1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。
java线程同步机制的方式：

方式一：同步代码块

同步代码块的格式：

synchronized(锁对象){
需要被同步的代码...
}


同步代码块要注意事项：
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。


方式二：同步函数  ：  同步函数就是使用synchronized修饰一个函数。

同步函数要注意的事项 ：
1. 如果是一个非静态的同步函数的锁 对象是this对象，如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件（class对象）。
2. 同步函数的锁对象是固定的，不能由你来指定 的。



推荐使用： 同步代码块。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定 的，不能由我们来指定。

2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数 的所有代码都被同步了。

[java]  view plain  copy

1. class SaleTicket extends Thread{  
2.           
3.       
4.      static int num = 50;//票数  非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。  
5.        
6.      static Object o = new Object();  
7.       
8.      public SaleTicket(String name) {  
9.         super(name);  
10.     }  
11.       
12.     @Override  
13.     public void run() {  
14.         while(true){  
15.             //同步代码块  
16.             synchronized (o) {                
17.                 if(num>0){  
18.                     System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");  
19.                     try {  
20.                         Thread.sleep(100);  
21.                     } catch (InterruptedException e) {  
22.                         e.printStackTrace();  
23.                     }  
24.                     num--;  
25.                 }else{  
26.                     System.out.println("售罄了..");  
27.                     break;  
28.                 }  
29.             }  
30.               
31.         }  
32.     }     
33.       
34.       
35. }   
36.   
37.   
38. public class Demo4 {  
39.       
40.     public static void main(String[] args) {  
41.         //创建三个线程对象，模拟三个窗口  
42.         SaleTicket thread1 = new SaleTicket("窗口1");  
43.         SaleTicket thread2 = new SaleTicket("窗口2");  
44.         SaleTicket thread3 = new SaleTicket("窗口3");  
45.         //开启线程售票  
46.         thread1.start();  
47.         thread2.start();  
48.         thread3.start();  
49.           
50.     }  
51.       
52. }  

需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。

[java]  view plain  copy

1. class BankThread extends Thread{  
2.       
3.     static  int count = 5000;  
4.       
5.     public BankThread(String name){  
6.         super(name);  
7.     }  
8.       
9.     @Override  //  
10.     public synchronized  void run() {  
11.         while(true){  
12.             synchronized ("锁") {                  
13.                 if(count>0){  
14.                     System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");  
15.                     count= count - 1000;  
16.                 }else{  
17.                     System.out.println("取光了...");  
18.                     break;  
19.                 }  
20.             }  
21.         }  
22.     }     
23.       
24.       
25.     //静态的函数---->函数所属 的类的字节码文件对象--->BankThread.class  唯一的。  
26.     public static synchronized  void getMoney(){  
27.           
28.     }  
29.       
30. }  
31.   
32.   
33. public class Demo1 {  
34.   
35.     public static void main(String[] args) {  
36.         //创建两个线程对象  
37.         BankThread thread1 = new BankThread("老公");  
38.         BankThread thread2 = new BankThread("老婆");  
39.         //调用start方法开启线程取钱  
40.         thread1.start();  
41.         thread2.start();  
42.           
43.           
44.     }  
45.       
46. }  

运行结果：
老公取走了1000块,还剩余4000元
老婆取走了1000块,还剩余3000元
老婆取走了1000块,还剩余2000元
老婆取走了1000块,还剩余1000元
老婆取走了1000块,还剩余0元
取光了...
取光了...

java中同步机制解决了线程安全问题，但是也同时引发死锁现象。

死锁现象出现 的根本原因：
1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。

死锁现象的解决方案： 没有方案。只能尽量避免发生而已。

[java]  view plain  copy

1. class DeadLock extends Thread{  
2.       
3.     public DeadLock(String name){  
4.         super(name);  
5.     }  
6.       
7.       
8.     public void run() {  
9.         if("张三".equals(Thread.currentThread().getName())){  
10.             synchronized ("遥控器") {  
11.                 System.out.println("张三拿到了遥控器，准备 去拿电池!!");  
12.                 synchronized ("电池") {  
13.                     System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");  
14.                 }  
15.             }  
16.         }else if("狗娃".equals(Thread.currentThread().getName())){  
17.             synchronized ("电池") {   
18.                 System.out.println("狗娃拿到了电池，准备去拿遥控器!!");  
19.                 synchronized ("遥控器") {  
20.                     System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");  
21.                 }  
22.             }  
23.               
24.         }     
25.     }  
26.       
27.       
28. }  

运行结果：
张三拿到了遥控器，准备 去拿电池!!
狗娃拿到了电池，准备去拿遥控器!!