Java总结(6)多线程（二）

线程状态

1、线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了这个对象后，线程就进入了初始状态;
2、当该对象调用了start()方法，就进入可运行状态;
3、进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态;
4、进入运行状态后情况就比较复杂了
　　4.1、run()方法或main()方法结束后，线程就进入终止状态;
　　4.2、当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片;
　　4.3、线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态;
　　4.4、当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被synchroniza(同步)，获取不到锁标记，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片;
　　4.5、当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

多线程的安全问题

问题的原因：      

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

解决办法：  

    对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与执行。  
同步代码块。  
    synchronized(对象){  
        //需要被同步的代码  
    }  
    对象如同锁，持有锁的线程可以在同步中执行。  
    没有持有锁的线程即使获取cpu执行权，也进不去，因为没有获取锁。  

同步的前提：  

        1.必须要有两个或者两个以上的线程。  
        2.必须是多个线程使用同一个锁  
    好处：解决了多线程的安全问题。  
    弊端：多个线程需要判断锁，较为消耗资源。  
    如何找问题：  

    1.明确哪些代码是多线程运行代码。  

    2.明确共享数据。  
    3.明确多线程运行代码中哪些语句是操作共享数据的。  

同步有两种形式： 

1.同步代码块 ： 

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

2.同步函数 ：

把synchronized作为修饰符放在函数上，此函数就具备了同步的特性。  
        同步函数用得到是哪一个锁呢？  
        函数需要被对象调用，那么函数都有一个所属对象引用，就是this。  
        所以同步函数使用的锁是this。利用如下代码验证：  

  private int tick = 100;          public void run(){              if(flag){                  while(true){                      synchronized(this/*此处未为验证精髓*/){                          //同步代码块                              if(tick>0){                              try{Thread.sleep(10);}catch(Exception e){}                              System.out.println(Thread.currentThread().getName()+"..code.."+tick--)                          }                      }                  }              }else                  while(true)                  show();          }          public synchronized void show(){              //需要同步的内容              if(tick>0){                  try{Thread.sleep(10);}catch(Exception e){}                  System.out.println(Thread.currentThread().getName()+"..show.."+tick--)              }          }          //通过观察输出票数是否安全便可知道，同步函数的锁是否是this          public void main(String args[]){              new Thread(对象).run();              //让线程等待10ms，以便确认0线程已进入代码块              try{Thread.sleep(10);}catch(Exception e){}              flag=false;              new Thread(对象).run();          }  

静态同步函数，使用的锁是什么呢？  
通过验证，不是this，因为静态方法中也不可以定义this。  
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。  
类名.class 该对象的类型是Class ，所使用的锁是该方法所在类的字节码文件对象。  

(重点)单例设计模式： 

饿汉式：  

 class Single{          //先创建对象，需要的时候直接调用          private static final Single s = new Single();          //将构造函数私有化，禁止外界的访问。          private Single(){}          public static Single getInstance(){              return s;          }      }  

懒汉式：   

class Single{          private static Single s = null;          private Single(){}          public static  Single getInstance(){              //双重判断，提高懒汉式的效率，一次创建对象以后，就不再需要判断锁              if(s==null){                  //多线程多次判断锁，影响效率                  synchronized(Single.class){                      //如果不存在对象，才要创建对象，称延迟加载                      if(s==null)                          s=new Single();                  }              }              return s;          }      }  

死锁：

所谓死锁： 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

例子：  

class Test1 implements Runnable  {      private boolean flag;      Test1(boolean flag)      {          this.flag = flag;      }      public void run()      {           if(flag)           {               while(true)              {                   synchronized(MyLock.locka)                   {                       System.out.println("if locka");                       synchronized(MyLock.lockb)                       {                           System.out.println("if lockb");                       }                   }               }           }           else           {               while(true)               {                   synchronized(MyLock.lockb)                   {                       System.out.println("else lockb");                       synchronized(MyLock.locka)                       {                           System.out.println("elcs locka");                       }                   }               }             }      }  }    class MyLock  {      static Object locka = new Object();      static Object lockb = new Object();  }  class  DeadLockTest  {      public static void main(String[] args)       {          new Thread(new Test1(true)).start();          new Thread(new Test1(false)).start();      }  }