十 多线程

Posted 2021-01-31 ltfxy

一、多线程的引入：

什么是线程？

•                程序执行的一条路径，一个进程中可以包含多个线程
•                多线程并发执行可以提高程序的效率，可以同时完成多项工作

多线程应用场景：

•             qq同时和多人聊天
•              服务器同时处理多个客户端请求

二、多线程并行和并发的区别：是否在某一时刻只有1可线程在运行

•     并行：两个任务同时运行，甲任务运行的同时，乙任务也在运行，需要多核CPU
•     并发：两个任务都请求运行，处理器只能处理一个请求，在短时间间隔内轮流进行，使人感觉两个任务同时在运行

 

三、关于JAVA的多线程

    1、Java程序运行原理
        Java命令会启动Java虚拟机，启动jvm,等于启动了一个应用程序(进程)。
        该进程会启动了一个主线程，然后主线程去调用某个类的main方法
    2、jvm的启动是多线程的吗？
        JVM开启至少启动了垃圾回收线程和主线程，所以是多线程的
        多次启动一个线程是非法的
   

四、多线程程序的两种实现方式

    方式一：继承Thread类
      1、继承Thread类，Override:run方法
      2、把新线程要做的事情写在run方法中
      3、创建线程对象
      4、执行start方法，启动新线程  
    方式二： 实现Runnable接口（建议使用，后期扩展性强）
       1、定义一个类实现Runnable接口
       2、重写run方法
       3、new一个Thread对象，利用Thread类的构造，将Runnable的子类对象当作参数传进去
       4、 执行Thread.start(),开启线程  
       

  

  原理(查看源码)：
       1、Thread实现了Runnable接口，通过Thread的构造函数，传递了Runnable接口的引用target(目标，靶子)
       2、通过Thread类的init方法，将传入引用target赋给成员变量target
       3、在Thread类的run方法中，如果target不为空，则线程开启时(start())会调用Runnable接口子类对象的run方法
    
      两种方式的区别：
      a：继承Thread：由于子类重写了Thread类的run方法，当调用start()时，直接找到子类的run方法
      b : 实现Runnable:Thread类的构造函数中传入了Runnable的引用，通过init方法将引用赋给了Runnable类型的成员变量target
                      在启动线程时，start方法调用run方法，在run方法里，判断target不为空的话，则调用target的run方法，  执行子类重写的run方法
      
      两种方式的好处和弊端：
      继承Thread:  
               好处是：可以直接调用Thread类的方法，代码简单
               弊端是：如果已经有了父类，则不能用这种方法，java单继承，多实现
      实现Runnable
               好处： 由于java单继承多实现，即使线程类有了父类也可以实现接口。
               弊端：不能直接使用Thread中的方法，需要先获取线程对象，再通过Thread的构造传入，代码复杂  
      

      匿名内部类实现线程的两种的方式：
        1、new Thread(){ @override public void run();    }.start();
        2、new Thread(new Runnable(){ @override public void run();}){}.start();

   五、线程的命名 

     1、默认： Thread.getName(): 默认Thread-序号(从1开始)      
     2、构造：Thread(String name)：构造命名 name
     3、设置：this.setName(String name)：      
     

 

   六、获取当前正在执行的线程

     Thread.currentThread()
     
   

   七、线程睡眠    

    Thread.sleep(毫秒，微妙),控制当前线程休眠若干时间  1秒：1000毫秒：1000微妙：1000纳秒  1秒=10亿纳秒
        

     八、守护线程： 

      Thread.setDaemon(boolean on)将该线程标记为守护线程或用户线程。    
       该线程不会单独执行，当其他的非守护线程都执行结束后，自动退出
       比如QQ聊天，把QQ退出，聊天界面也会关闭，聊天界面可以理解为守护线程
  

     九、加入线程,插队

    join,当前线程暂停，等待指定的线程执行结束以后，当前线程再继续
    join(int),插队，等待指定的毫秒之后，两条线程交替执行         
   

  十、礼让线程

     yield让出cpu  
 

   十一、设置线程的优先级

     setProperties()设置线程优先级 ,最小是1,最大是10,默认是5
   

   十二、同步代码块

     1、什么情况下需要同步
          当多线程并发、有多段代码同时执行时，我们希望某一段代码执行的过程中不要切换到其他线程工作。 这时就需要同步。
          如果两段代码是同步的，那么同一时间只能执行一段，在一段代码没执行结束之前，不会执行另一段代码。
     2、同步代码块
          使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块。
          多个同步代码块如果使用相同的锁对象，那么他就是同步的。
          锁对象是任意的，但不能是匿名对象，匿名对象不是同一个对象
          同步代码块中，用哪个对象锁，就用哪个对象调用wait方法
       

十三、同步方法及其锁对象   

    如何保证锁是一致的？

     对于继承Thread方式：
               在方法上加synchronized关键字
               对于静态方法，锁对象是this
               对于非静态方法，锁对象是当前类的字节码对象   
     对于实现Runnable接口方式：
                锁对象可以是this，因为只创建了一个Runnable引用对象传进Thread的构造
                    

     十四、死锁  

         多个线程相互等待
         避免同步代码块的嵌套

       

 

     

     十五、回顾以前的线程安全问题

         看源码：Vector、StringBuffer、HashTable、Collection.synchronized(xxx)
         Vector是线程安全的,ArrayList是线程不安全的
         StringBuffer是线程安全的，StringBuilder是线程不安全的
         HashTable是线程安全的，HashMap是线程不安全的
         Collection.synchronized(xxx):返回线程安全的集合
               
    

      十六、多线程之单例设计模式

       单例设计模式：保证类在内存中只有一个对象
       
      如何保证类在内存中只有一个对象？
     1、控制类的创建，不让其他类类创建本类的对象
     2、在本类中定义一个本类的对象
     3、提供公共的访问方式  
       
        单例设计模式的两种写法：
        饿汉式：      
        private Singleton(){  }
        //创建本类对象,私有化，相当于成员变量
        private static Singleton s = new Singleton();
        //对外提供一个公共的访问方式
        public static Singleton getInstance(){
        return s;
    }
        懒汉式：
    private Singleton(){  }
    private static Singleton s;
    public static Singleton getInstance(){
        if(s==null){
            //线程1等待，线程2等待，线程1执行，线程2执行，有可能造成2次对象的情况
            s = new Singleton();
        }
        return s;
    }
 

   其他写法：
    private Singleton(){  }
    //创建本类对象,私有化，相当于成员变量
    private static Singleton s = new Singleton();
    //对外提供一个公共的访问方式
    public static Singleton getInstance(){
    return s;
    }
    饿汉式和懒汉式的区别：
    1 饿汉式是空间换时间(一上来就创建对象)，懒汉式是时间换空间(需要判断，浪费时间)
    2 在多线程访问时，饿汉式不会创建多个对象，而懒汉式有可能创建多个对象(如果判断的时候产生线程等待)
    
      

    十七、单例设计模式的应用场景：RunTime类

    Runtime类是一个单例类，查看源码发现构造方法私有，并且是饿汉式的单例形式
    r.exec("shutdown -s -t 300")://5分钟之后关机
     

   十八、Timer类：计时器，实现了Runnable接口

     Timer.schedule(task, delay):在指定的时间做指定的事情
     Timer.schedule(task, delay, period);period之后再做同样的事情，比如闹钟
    

    十九、两个线程间的通信

    1、什么时候需要通信
    多个线程并发执行时，在默认的情况下CPU是随机切换线程的
    如果我们希望他们有规律的执行，就可以使用通信，例如每个线程执行一次打印
    2、怎么通信
    线程等待 wait()，同步代码块中，用哪个对象锁，就用哪个对象调用wait方法
    线程唤醒，notify()，notifyAll();
    这两个方法必须在同步代码块中执行，并且使用同步锁对象来调用
        
  

    二十、wait()、Sleep()和notify()

    为什么wait和notify方法定义在Object类中？
               因为锁对象可以使任意对象，Object是所有类的基类，所以需要这么定义
    sleep和wait的区别？
       (a)sleep在Thread类中，需要传入参数，就是时间，时间到了就醒来
       wait在Object类中，方法可以传入参数，也可以不传入参数 ，传入参数则在参数时间后等待，不传则直接等待
           传参时。sleep睡一阵子就起来，wait一阵子之后就睡    
       (b)slepp在同步函数或者同步代码块中不释放锁(睡着了也抱着锁)    
        wait在同步函数或这同步代码块中释放锁      
        
    

     二十一、 jdk1.5新特性，互斥锁

     1.同步，使用ReenTrantLock类的lock()和unlock()方法进行同步
            lock()获取锁，unlock()释放锁
     2.通信,
                             使用ReenTrantLock类的newCondition()方法获取Condition对象
                             需要等待的时候使用Condition的await()方法，唤醒的时候用signal()方法
                             不同的线程使用不同的condition，这样就能区分唤醒的时候找哪个线程了
     3.常用方法：
         ReenTrantLock.lock():获得锁                      
         ReenTrantLock.unlock():释放锁                      
         ReenTrantLock.await():等待                                                
         ReenTrantLock.signal():唤醒                      
     
 

   二十二、线程组

       线程组概述：
       Java中使用ThreadGroup来表示线程组，对一批线程进行分类管理，java允许程序直接对线程组进行控制
           默认情况下，所有现场都属于主线程组
           我们也可以给线程设置分组                        
         

  二十三、线程的生命周期（此处应有图）

        新建：创建线程对象[thread、runnable]
        就绪：线程对象已经启动，但没有获得CPU执行权[start()]
        运行：获取到了CPU执行权[抢到了CPU执行权]
        阻塞：没有CPU的执行权，回到就绪[sleep()、wait()]
        死亡：代码运行完毕，线程消亡，变成垃圾  [run()结束、stop(方法过时)]
       
 

 

     

 

     二十四、多线程实现的第三种方式，callable(了解)          

 

       二十五、设计模式之简单工厂模式的概述和使用       

       简单工厂模式：
           又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
       优点：
        客户端不需要负责对象的创建，从而明确了每个类的职责
       缺点：
       这个静态工厂类负责所有对象的创建，如果有对象添加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期维护
       
              

       二十六、工厂方法模式的概述、使用和了解   

       工厂方法模式概述：
         抽象工厂类定义创建对象的接口，具体对象的创建工作由抽象工厂类的各个实现类来完成
       优点：
         客户端不需要负责对象的创建，明确了个各类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可
        不影响已有代码，便于后期维护，增强了系统的扩展性
       缺点：
        需要额外的编写代码，增加了工作量