黑马程序员系列第一篇 多线程（1）

 

（前言：本篇文章主要依据毕向东老师的课程视频整理而成，如要详细学习，请观看毕老师视频  百度网盘链接地址：http://pan.baidu.com/s/1sjQRHDz）

目录：一、线程的两种创建方式        二、线程的五种状态、线程操作中常用的方法        三、多线程安全  四、使用同步的弊端         五、单例设计模式中的多线程（面试重点）

一、线程的两种创建方式

      1、实现Runnable接口（主流）

          代码示例：

public class ThreadTest{
    
    public static void main(String[] args) throws InterruptedException{
      ThreadImple ti=new ThreadImple();
      Thread thread=new Thread(ti);
      
      thread.start();
}
}
 class ThreadImple implements Runnable {

    @Override
    public void run() {
        for(int i=0;i<60;i++)
        System.out.println("thread implements runnable..."+i);
    }
}

      2、继承Thread类

     

public class ThreadTest{
    
    public static void main(String[] args) throws InterruptedException{
      ThreadExtends ti=new ThreadExtends();
   
        ti.start();
}
}
 class ThreadExtends extends Thread {

    public void run() {
        for(int i=0;i<60;i++)
        System.out.println("extend thread class..."+i);
    }
}

      3、两种创建方式的区别

            实现方式的运行代码存放在接口子类的run方法中；实现方式避免了单继承的局限性，建议使用

        继承方式的运行代码存放在Thread子类的run方法中

   

二、线程的五种状态    线程操作中常用的方法

 

三、多线程安全

        问题：一个线程操作多条语句来共享数据时，一个线程对多条语句只执行了一部分，另一个线程便参与进来执行了，导致共享数据出错。

        如何寻找问题：  1、明确哪些代码示多线程运行代码     2、明确共享数据     3、明确多线程运行代码中哪些语句是操作共享数据的。

  解决办法：同步代码块：

             Synchronized( 锁 ){

                  需要被同步的代码；

             }

                       同步函数：在函数前加synchronized修饰符。

  使用同步要满足三个前提：1、必须有两个或两个以上线程  2、必须是多个线程使用同一个锁

  弊端：每次执行时都要判断锁，浪费资源。

  普通同步函数的锁是this ，静态函数的锁是其所在文件字节码对象（.class）

      简单模拟售票代码：

/*
程序一共创建三个线程模拟三个售票窗口   ticket=100将票号设为1-100  我们希望票号不重复
遗憾的是结果会出现票号为负数、相同票号的问题      也就是我们要讲到的线程不安全问题
*/
public class SaleTicketUnsafe {

    public static void main(String[] args) {

        Ticket ticket=new Ticket();
        
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
        
    }

}
class Ticket implements Runnable{
  
   private int ticket=100;
   public void run(){
    while(true){
        if(ticket>0){
            try {
                Thread.sleep(10);//线程出错概率不是很大，所以要让线程休眠sleep()来将问题暴露出来
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        System.out.println(Thread.currentThread().getName()+"售票口出售---车票号："+ticket--);
        }
    }
        
   }
}

     使用同步代码块的方式改进后的程序

   

/*同步代码块的方式解决了问题*/
public class SaleTicketSafe {

    public static void main(String[] args) {
        Tickets ticket=new Tickets();
        
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }

}
class Tickets implements Runnable{
    
    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while(true){
            synchronized(obj){//同步代码块
            if(ticket>0){
                try {
                    Thread.sleep(10);
                    } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            System.out.println(Thread.currentThread().getName()+"售票口出售---车票号："+ticket--);
            }    
            }
        }
    }
    
}

四、使用同步会出现死锁情况（面试时会要求写一个死锁程序）

      问题：多线程各自持有不同的锁没释放，而又彼此需要对方的锁。

    原因：同步中嵌套同步，而它们的锁却不同

 一个简单的死锁程序：

public class DieLock {
    
  public static void main(String[] args){
    //开启两个线程测试
    Thread t1=new Thread(new Test(true));
    t1.start();
    Thread t2=new Thread(new Test(false));    
    t2.start();    
   }
}
class Test implements Runnable{
    boolean flag;
    public Test(boolean f){
        this.flag=f;
    }
    @Override
    public void run() {
        if(flag){
            while(true){
            synchronized(Lock.lockb){
                System.out.println("if locka");
                synchronized(Lock.locka){
                    System.out.println("if lockb");    
                }
            }
            }
        }else{
            while(true){
            synchronized(Lock.locka){
                System.out.println("else locka");
                synchronized(Lock.lockb){
                    System.out.println("else lockb");    
                }
            }
            }
        }        
}
    //单独定义两个不同的锁
static class Lock{
     static Object locka=new Object();
     static Object lockb=new Object();
}        
}

五、单例设计模式中的多线程（面试重点）

       饿汉式、懒汉式（是线程不安全的，需要同步）

       将懒汉式同步有两种方式：

        1、下面代码中在getInstance方法前用synchronized修饰，通过同步函数来解决，每次都要同步比较消耗资源   

        2、就是注释中用同步块的方式，用双重判断（s==null）只需同步一次，避免多消耗资源，推荐使用

public class Single{
    public static void main(String[] args){
        
        Singlel s=Singlel.getInstance();
        
    }
}
//懒汉式
 class Singlel extends Single{

     private Singlel(){}
    private static Singlel s=null;
    
    public static synchronized Singlel getInstance(){
        if(s==null)
          s=new Singlel();
//        if(s==null){
//            synchronized(Singlel.class){    方法二、双重判断 ，提高效率
//                if(s==null)
//                    s=new Singlel();
//            }
//        }
        return s;
    }
}
 //饿汉式
 class Singlee extends Single{
     private  Singlee(){}
    private static Singlee s=new Singlee();
    
    public static Singlee getInstance(){
        return s;
    }
    
}

       

       初学者难免错误，欢迎评判指教，持续更正ing...........