Java学习笔记 24 - 线程之多线程安全、死锁、同步机制

本文主要内容
1、多线程安全问题
2、等待唤醒机制

01线程安全

  • A:线程安全问题引发
    多线程并发访问同一个数据资源时,线程休眠,会导致线程安全问题

    /*
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
     public static void main(String[] args) {
     //创建Runnable接口实现类对象
     Tickets t = new Tickets();
     //创建3个Thread类对象,传递Runnable接口实现类
     Thread t0 = new Thread(t);
     Thread t1 = new Thread(t);
     Thread t2 = new Thread(t);
     
     t0.start();
     t1.start();
     t2.start();
     
     }
    }
    
    /*
     *  通过线程休眠,出现安全问题
     */
    public class Tickets implements Runnable{
    
     //定义出售的票源
     private int ticket = 10;
     private Object obj = new Object();
    
     public void run(){
     while(true){
    
       //对票数判断,大于0,可以出售,变量--操作
         if( ticket > 0){
           try{
              Thread.sleep(10); //加了休眠让其他线程有执行机会
           }catch(Exception ex){}
           System.out.println(Thread.currentThread().getName()+"正在售票 "+ticket--);
         }
     }
     }
    }
    

输出结果:
窗口3正在售票10
窗口2正在售票9
窗口1正在售票8
窗口1正在售票7
窗口3正在售票7
窗口2正在售票6
窗口3正在售票5
窗口1正在售票5
窗口2正在售票4
窗口3正在售票3
窗口2正在售票2
窗口1正在售票3
窗口3正在售票1
窗口1正在售票0
窗口2正在售票-1
上面程序存在以下问题:
票出现了重复的票
错误的票 0、-1
这里由多个线程同时对变量执行写操作而引起的线程安全问题,解决该问题需要考虑线程同步。

  • B:同步代码块解决线程安全问题
    通过线程休眠,导致的安全问题,解决方案:同步代码块
    公式:
    synchronized(任意对象){
    线程要操作的共享数据
    }

        /*
         * 3个线程,对一个票资源,出售
         */
        public class ThreadDemo {
         public static void main(String[] args) {
           //创建Runnable接口实现类对象
           Tickets t = new Tickets();
           //创建3个Thread类对象,传递Runnable接口实现类
           Thread t0 = new Thread(t);
           Thread t1 = new Thread(t);
           Thread t2 = new Thread(t);
           
           t0.start();
           t1.start();
           t2.start();
           
         }
        }
      
        public class Tickets implements Runnable{
         
         //定义出售的票源
         private int ticket = 100;
         private Object obj = new Object();
         
         public void run(){
           while(true){
             //线程共享数据,保证安全,加入同步代码块
             synchronized(obj){
             //对票数判断,大于0,可以出售,变量--操作
               if( ticket > 0){
                 try{
                    Thread.sleep(10);
                 }catch(Exception ex){}
                 System.out.println(Thread.currentThread().getName()+" 正在售票 "+ticket--);
               }
             }
           }
         }
        }
    

输出结果:
窗口1正在售票10
窗口1正在售票9
窗口1正在售票8
窗口1正在售票7
窗口1正在售票6
窗口1正在售票5
窗口1正在售票4
窗口1正在售票3
窗口1正在售票2
窗口1正在售票1

  • C:同步代码块的执行原理
    同步代码块: 在代码块声明上 加上synchronized
    synchronized (锁对象) {
    可能会产生线程安全问题的代码
    }
    同步代码块中的锁对象可以是任意的对象;但多个线程时,要使用同一个锁对象才能够保证线程安全。

  • D:同步方法的使用
    同步方法是将线程共享数据、同步,抽取到一个方法中。在方法的声明上,加入同步关键字
    同步普通方法和同步代码块一样,有锁且对象锁是本类对象的引用,即this
    同步静态方法的对象锁是本类类名.class属性

     public class Tickets implements Runnable{
    
    //定义出售的票源
    private  int ticket = 100;
    
    public void run(){
      while(true){
        payTicket();
      }
    }
    
    public  synchronized void payTicket(){  
        if( ticket > 0){
          try{
             Thread.sleep(10);
          }catch(Exception ex){}
          System.out.println(Thread.currentThread().getName()+" 正在售票 "+ticket--);
        }
      
    }
     }
    

输出结果:
窗口2正在售票10
窗口2正在售票9
窗口2正在售票8
窗口2正在售票7
窗口2正在售票6
窗口2正在售票5
窗口2正在售票4
窗口2正在售票3
窗口2正在售票2
窗口2正在售票1

02 Lock接口

  • A:JDK1.5新特性Lock接口
    Lock接口提供了比使用 synchronized 方法和语句更加面向对象的锁,在该锁中提供了更多的操作锁的功能。
    Lock接口中的常用方法
    void lock()
    void unlock()
    使用Lock接口,以及其中的lock()方法和unlock()方法可替代同步

  • B:Lock接口的使用

    /*
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
      public static void main(String[] args) {
        //创建Runnable接口实现类对象
        Tickets t = new Tickets();
        //创建3个Thread类对象,传递Runnable接口实现类
        Thread t0 = new Thread(t);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        
        t0.start();
        t1.start();
        t2.start();
        
      }
    }
    
    public class Tickets implements Runnable{
      
      //定义出售的票源
      private int ticket = 100;
      //在类的成员位置,创建Lock接口的实现类对象
      private Lock lock = new ReentrantLock();
      
      public void run(){
        while(true){
          //调用Lock接口方法lock获取锁
            lock.lock();
          //对票数判断,大于0,可以出售,变量--操作
            if( ticket > 0){
              try{
                 Thread.sleep(10);
                 System.out.println(Thread.currentThread().getName()+" 正在售票 "+ticket--);
              }catch(Exception ex){
                
              }finally{
                //释放锁,调用Lock接口方法unlock
                lock.unlock();
              }
            }
        }
      }
    }
    

03线程的死锁

  • A:线程的死锁原理
    当线程任务中出现了多个同步(多个锁) 时,如果同步中嵌套了其他的同步。这时容易引发一种现象:程序出现无限等待,这种现象我们称为死锁。

        synchronzied(A锁){
          synchronized(B锁){
                    
          }
      }
    
  • B:线程的死锁代码实现

     public class DeadLock implements Runnable{
      private int i = 0;
      public void run(){
        while(true){
          if(i%2==0){
            //先进入A同步,再进入B同步
            synchronized(LockA.locka){
              System.out.println("if...locka");
              synchronized(LockB.lockb){
                System.out.println("if...lockb");
              }
            }
          }else{
            //先进入B同步,再进入A同步
            synchronized(LockB.lockb){
              System.out.println("else...lockb");
              synchronized(LockA.locka){
                System.out.println("else...locka");
              }
            }
          }
          i++;
        }
      }
     }
    
    public class DeadLockDemo {
      public static void main(String[] args) {
        DeadLock dead = new DeadLock();
        Thread t0 = new Thread(dead);
        Thread t1 = new Thread(dead);
        t0.start();
        t1.start();
      }
    }
    
    
    public class LockA {
      private LockA(){}
      
      public  static final LockA locka = new LockA();
    }
    
    
    public class LockB {
      private LockB(){}
      
      public static final LockB lockb = new LockB();
    }
    

04线程等待与唤醒

  • A:线程等待与唤醒
    等待唤醒机制所涉及到的方法:
    wait() :等待,将正在执行的线程释放其执行资格 和 执行权,并存储到线程池中。
    notify():唤醒,唤醒线程池中被wait()的线程,一次唤醒一个,而且是任意的。唤醒:即让线程池中的线程具备执行资格
    notifyAll(): 唤醒全部:可以将线程池中的所有wait() 线程都唤醒。
    上述方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁,这样才可以明确出这些方法操作的到底是哪个锁上的线程。

  • B:案例

    /*
     *  定义资源类,有2个成员变量
     *  name,sex
     *  同时有2个线程,对资源中的变量操作
     *  1个对name,age赋值
     *  2个对name,age做变量的输出打印
     */
    public class Resource {
    public String name;
    public String sex;
    }
    
    
     /*
     *  输入的线程,对资源对象Resource中成员变量赋值
     *  一次赋值 张三,男
     *  下一次赋值 lisi,nv
     */
    public class Input implements Runnable {
      private Resource r=new Resource();
     
      public void run() {
        int i=0;
        while(true){
          if(i%2==0){
             r.name="张三";
             r.sex="男";
           }else{
              r.name="lisi";
              r.sex="女";
            }
          i++;
        }
      }
    }
    
    /*
     *  输出线程,对资源对象Resource中成员变量,输出值
     */
    public class Output implements Runnable {
      private Resource r=new Resource() ;
       
      public void run() {
        while(true){
           System.out.println(r.name+"..."+r.sex); 
          }
        }
    }
    
    
    /*
     *  开启输入线程和输出线程,实现赋值和打印值
     */
    public class ThreadDemo{
      public static void main(String[] args) {
        
        Resource r = new Resource();
        
        Input in = new Input();
        Output out = new Output();
        
        Thread tin = new Thread(in);
        Thread tout = new Thread(out);
        
        tin.start();
        tout.start();
      }
    }
    

以上程序运行后,输出结果中Resource对象会有很多Null值
null.....null
null.....null
null.....null
null.....null
null.....null
null.....null
null.....null
null.....null
null.....null
.....

解决上述Null值,线程等待与唤醒案例null值解决

    /*
    *  输入的线程,对资源对象Resource中成员变量赋值
    *  一次赋值 张三,男
    *  下一次赋值 lisi,nv
  */
   public class Input implements Runnable {
     private Resource r;
     public Input(Resource r){
       this.r=r;
     }
    
     public void run() {
       int i=0;
       while(true){
         if(i%2==0){
            r.name="大王";
            r.sex="男";
          }else{
             r.name="王后"
             r.sex="女"
           }
         i++;
       }
     }
   }

   /*
    *  输出线程,对资源对象Resource中成员变量,输出值
    */ 
   public class Output implements Runnable {
     private Resource r;
     public Output(Resource r){
        this.r=r;
     } 
     public void run() {
       while(true){
          System.out.println(r.name+"..."+r.sex); 
         }
       }
     }

   }
   /*
    *  开启输入线程和输出线程,实现赋值和打印值
    */
   public class ThreadDemo{
     public static void main(String[] args) {
       
       Resource r = new Resource();
       
       Input in = new Input(r);
       Output out = new Output(r);
       
       Thread tin = new Thread(in);
       Thread tout = new Thread(out);
       
       tin.start();
       tout.start();
     }
   }

以上程序运行,打印输出的结果发现,会有交叉错乱
大王.....男
王后.....女
王后.....男
大王.....女
王后.....女
王后.....女
大王.....女
王后.....男
王后.....男
王后.....男
大王.....女
王后.....男
大王.....男
.....
解决方案:使用同步代码块

        /*
          *  输入的线程,对资源对象Resource中成员变量赋值
          *  一次赋值 张三,男
          *  下一次赋值 lisi,nv
        */
         public class Input implements Runnable {
           private Resource r;
           public Input(Resource r){
             this.r=r;
           }
          
           public void run() {
             int i=0;
             while(true){
              synchronized(r){
               if(i%2==0){
                   r.name="大王";
                   r.sex="男";
              }else{
                   r.name="王后"
                   r.sex="女"
                 }
               i++;
             }

           }
         }

         /*
          *  输出线程,对资源对象Resource中成员变量,输出值
          */ 
         public class Output implements Runnable {
           private Resource r;
           public Output(Resource r){
              this.r=r;
           } 
           public void run() {
             while(true){
                synchronized(r){
                 System.out.println(r.name+"..."+r.sex); 
                }
               }
             }
           }

         }
         /*
          *  开启输入线程和输出线程,实现赋值和打印值
          */
         public class ThreadDemo{
           public static void main(String[] args) {
             
             Resource r = new Resource();
             
             Input in = new Input(r);
             Output out = new Output(r);
             
             Thread tin = new Thread(in);
             Thread tout = new Thread(out);
             
             tin.start();
             tout.start();
           }
         }

以上程序运行,打印输出的结果发现,仍会有错乱

...男
大王.....男
大王.....男
大王.....男
大王.....男
大王.....男
大王.....男
大王.....男
......
解决方案:使用线程等待与唤醒
输入:赋值后,执行方法wait()永远等待
输出:变量值打印输出,在输出等待之前,唤醒
输入的notify(),自己在wait()永远等待
输入:被唤醒后,重新对变量赋值,赋值后,必须唤醒输出的线程notify(),自己的wait()

 /*
  *  定义资源类,有2个成员变量
  *  name,sex
  *  同时有2个线程,对资源中的变量操作
  *  1个对name,age赋值
  *  2个对name,age做变量的输出打印
  */
 public class Resource {
  public String name;
  public String sex;
  public boolean flag = false;
 }

 /*
  *  输入的线程,对资源对象Resource中成员变量赋值
  *  一次赋值 张三,男
  *  下一次赋值 lisi,nv
  */
 public class Input implements Runnable {
  private Resource r ;
  
  public Input(Resource r){
    this.r = r;
  }
  
  public void run() {
    int i = 0 ;
    while(true){
      synchronized(r){
        //标记是true,等待
          if(r.flag){
            try{r.wait();}catch(Exception ex){}
          }
        
        if(i%2==0){
            r.name="大王";
            r.sex="男";
          }else{
             r.name="王后"
             r.sex="女"
        }
        //将对方线程唤醒,标记改为true
        r.flag = true;
        r.notify();
      }
      i++;
    }
  }

 }
 
 /*
  *  输出线程,对资源对象Resource中成员变量,输出值
  */
 public class Output implements Runnable {
  private Resource r ;
  
  public Output(Resource r){
    this.r = r;
  }
  public void run() {
    while(true){
      synchronized(r){  
        //判断标记,是false,等待
      if(!r.flag){
        try{r.wait();}catch(Exception ex){}
        }
      System.out.println(r.name+".."+r.sex);
      //标记改成false,唤醒对方线程
      r.flag = false;
      r.notify();
      }
    }
  }

 }

 /*
  *  开启输入线程和输出线程,实现赋值和打印值
  */
 public class ThreadDemo{
  public static void main(String[] args) {
    
    Resource r = new Resource();
    
    Input in = new Input(r);
    Output out = new Output(r);
    
    Thread tin = new Thread(in);
    Thread tout = new Thread(out);
    
    tin.start();
    tout.start();
  }
 }

你可能感兴趣的:(Java学习笔记 24 - 线程之多线程安全、死锁、同步机制)