Java 多线程的安全问题

    ------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

      多线程是一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个线程,彼此间相互独立线程安全 ,是指变量或方法 (这些变量或方法是多线程共享的)可以在多线程的环境下被安全有效的访问。这说明了两方面的问题：

        (1)可以从多个线程中调用,无需调用方有任何操作；

        (2)可以同时被多个线程调用,无需线程之不必要的交互。

1.  发现安全隐患：

      需求：用Java的多线程模拟火车站的四个售票窗口同时售票  

示例代码1：

package com.itheima.day11;

class Ticket1implements Runnable{
      private int tick = 100;   

      public void run(){  
           while(true){
                 if(tick>0){
                       System.out.println(Thread.currentThread().getName()+" sale:"+tick--);
            }
            
        }
    }
}

public class ThreadRunnableDemo {

    public static void main(String[] args) {
        Ticket1 t = new Ticket1();

         Thread t1 = new Thread(t);
         Thread t2 = new Thread(t);
         Thread t3 = new Thread(t);
         Thread t4 = new Thread(t);

           t1.start();
           t2.start();
           t3.start();
           t4.start();
      }

}

2. 现象：

      

       从运行结果中发现，发现打印出了：0，-1，-2这样的车票，多线程的运行出现了安全问题
 成员变量tick是多个线程共享 的数据

3.问题的原因：
           当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完
   就有另一个线程参与进来执行，导致共享数据的错误

4.解决方案：
              对多条操作共享数据的语句，只能让一个线程执行完，在执行过程中，其他线程不可以参与执行

             Java中对于多线程的安全问题提供了专业的解决方案：同步代码块

     格式：

              synchronized(对象){
     需要被同步的代码
     }
        其中的对象是随便可以放的， 该对象如同锁（监视器），持有锁的线程可以在同步中执行，没有翅锁的线程，
  即使获得了CPU的执行权，也进不去，因为没有锁  

 

示例代码2：

class Ticket2 implements Runnable{
    private inttick = 100;
    Object obj = new Object();
    
    public void run(){   //run()方法中全都是线程运行代码，tick为共享数据
       while(true){
            synchronized(obj){
              if(tick>0){
                   try{
                     Thread.sleep(10);  //此时不能抛出异常，只能用try处理
                     }catch(Exception e){ }
                    
                  }
                
                System.out.println(Thread.currentThread().getName()+"..sale:"+tick--);
            }
        }
        
    }
}

public class ThreadSecurity {

    public static void main(String[] args) {
        Ticket2 t = new Ticket2();
        
        Thread t1 = new Thread(t);
        Thread t2 = newThread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        
     }

}

注意：
     必须保证同步只能有一个线程在运行
     不是所有的run()中的代码都要进行同步
 
 好处： 解决了多线程的安全问题
 弊端： 多个线程需要判断锁，较为消耗资源
 
  
  5.  run()方法中全都是线程运行代码，哪些代码在操作共享数据，则哪些代码就需要被同步
          
   <1>. Thread类中提供了static的 sleep()方法 ，sleep(),单位为millis(毫秒)，
 

     在指定的毫秒数内让当前正在执行的线程休眠
 

  <2>.这个方法会抛出（声明）异常 ，要对其进行处理，处理方式有两种

 
6. 同步函数的锁（监视器）

    <1> .问题：同步函数用的是哪一个锁？
 
     <2>.函数需要被对象调用，那么函数都有一个所属对象的引用，就是this，所以同步函数所使用的锁是this
  
  .<3>.验证：
  使用两个线程来卖票：
      一个线程在同步代码块中
      一个代码在同步函数中
      都在执行卖票的动作
    如果出现了错误，即就是没有实现同步，若没有错误即实现了同步，也就证明了同步函数的锁就是this
  
7. 静态同步的锁是Class对象

      <1> .  如果同步函数被static修饰后，使用的锁是什么呢？

      <2> . 通过验证，发现同步函数被static修饰后锁已经不再是this,(又出现了第0张票的情况，不安全了),因为静态方法中也不可能定义this
 
      <3>.   静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象
            即——类名.class 该对象的类型是Class,所以同步代码块中的对象为(Ticket3.class)
     <4> .  静态的同步方法，使用的锁是该方法所在类的字节码文件对象，即类名.class
 
     <5> . 只要是用到同步代码块的两个线程用同一个锁，其括号中的锁只要是示例中唯一的所属对象或者唯一的
       对象的字节码文件文件，都可以作为对象来使用

 示例代码3：

class Ticket3implements Runnable{
    private static int tick = 100;
   Object obj = new Object();//任意创建的对象
    boolean flag = true; //标记
    public void run(){   //同步代码块
        if(flag){
        while(true){
            synchronized(Ticket3.class){ //obj锁,换为this
            if(tick>0){
                try{Thread.sleep(100);}catch(Exception e ){}
                 System.out.println(Thread.currentThread().getName()+"..code.."+tick--);

                //show方法一定被对象调用，所以show()方法之前省略了this,show有所属对象
               show();
              }
        
             }
          }
      }else{
             while(true)
                 show();
      }
   }
    
    public static synchronized void show(){  //同步函数,this锁
        if(tick>0){
              try{Thread.sleep(10);}catch(Exception e ){}
             System.out.println(Thread.currentThread().getName()+"....show...."+tick--);
        }
     }
}
public class ThreadThisLockDemo {

    public static void main(String[] args) {
        //此时有3个线程，主线程开启之后，创建对象之后，再开启 t1,t2两个线程
        Ticket3  t = new Ticket3();
        
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        //Thread t3 = new Thread(t);
        //Thread t4 = new Thread(t);
        
        t1.start();  //开启之后不一定先执行，处于临时状态
            
                       //主线程开启之后很有可能将flag和t2直接执行完，主线程已经结束，剩下两个线程t1和t2
                    
        
        try{Thread.sleep(10);}catch(Exception e){}  //所以先让主线程停一下（10millis）,此时能运行的只有t1,过了10秒
        t.flag = false;        //之后主线程被唤醒，然后才会将flag切换为false，再去执行t2
        t2.start();
        
        
        t3.start();
        t4.start();
        }

}