您的位置: 首页  >  文章  >  java线程安全与死锁

java线程安全与死锁

分类: 文章 • 2022-11-05 11:48:11
线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。

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

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

相关推荐