多线程实现与lambda表达式

多线程

定义：在一个进程中实现多个线程并发执行

• 进程：一个程序被运行是称作进程
• 线程：进程中独立运行的片段称作线程，如main方法

多线程创建方法

• 继承Thread类

  • 继承Thread类并重写run方法做为线程体后使用start方法开启线程

     public class Demo01  extends Thread{
         @Override
         public void run() {
             //多线程方法体
         }
     
         public static void main(String[] args) {    //main线程
             Demo01 de = new Demo01();       //建立对象
             de.start();     //开启线程
             //main线程方法体
         }
     }
    

  • run方法线程会与main方法线程交替进行，由于时间片段很短可以实现并发执行

• 实现Runnable接口

  • 实现Runnable接口并重写run方法做为线程体后创建Thread对象，使用start方法开启线程

     public class Demo02 implements Runnable{
         @Override
         public void run() {
             //多线程方法体
         }
         public static void main(String[] args) {
             Demo02 d2 = new Demo02();
             //Thread thread = new Thread(d2);   创建线程对象
             //thread.start();
             //可简化为
             new Thread(d2).start();
         }
     }
    

  • 优点：避免单继承局限性，更加灵活

• 实现Callable接口

  • 实现Callable接口并重写call方法，之后建立线程池，实现多线程

     import org.apache.commons.io.FileUtils;
     
     import java.io.File;
     import java.io.IOException;
     import java.net.URL;
     import java.util.concurrent.*;
     
     public class Demo03 implements Callable<Boolean> {
         @Override
         public Boolean call() {
             //多线程方法体
             return true;
         }
     
         public static void main(String[] args) throws ExecutionException, InterruptedException {
             Demo03 d1 = new Demo03();
             //创建执行服务
             ExecutorService ser = Executors.newFixedThreadPool(1);
             //提交执行
             Future<Boolean> result1 = ser.submit(d1);
             //结果获取（返回值）
             boolean rd1 = result1.get();
             //关闭服务
             ser.shutdown();
         }
     }
    

  • 优点：

    • 可以定义返回值
    • 可以抛出异常

Lambda表达式

作用：简化函数式接口的实现方式

• 函数式接口：只定义了一个抽象方法的接口

函数式接口的实现：Lambda表达式的简化过程

• 实现类实现接口：

   public class Lambda {
       public static void main(String[] args) {
           Ilike i =new like();
           i.number();
       }
   }
   interface Ilike {   //函数式接口
       void number();
   }
   class like implements Ilike{    //实现类
       @Override
       public void number() {
           System.out.println("Hello World");
       }
   }
  

• 静态内部类实现接口：

   public class Lambda {
       static class like implements Ilike{     //静态内部类
           @Override
           public void number() {
               System.out.println("Hello World");
           }
       }
       public static void main(String[] args) {
           Ilike i =new like();
           i.number();
       }
   }
   interface Ilike {   //函数式接口
       void number();
   }
  

• 局部内部类实现接口：

   public class Lambda {
   
       public static void main(String[] args) {
           class like implements Ilike{    //局部内部类
               @Override
               public void number() {
                   System.out.println("Hello World");
               }
           }
           Ilike i =new like();
           i.number();
       }
   }
   interface Ilike {   //函数式接口
       void number();
   }
  

• 匿名内部类实现接口：

   public class Lambda {
   
       public static void main(String[] args) {
           Ilike i = new Ilike() {     //匿名内部类
               @Override
               public void number() {
                   System.out.println("Hello World");
               }
           };
           i.number();
       }
   }
   interface Ilike {   //函数式接口
       void number();
   }
  

• lambda表达式实现接口：

   public class Lambda {
   
       public static void main(String[] args) {
   
          Ilike i = ()->{      //lambda表达式
              System.out.println("Hello World");
          };
           i.number();
       }
   }
   interface Ilike {   //函数式接口
       void number();
   }
  

lambda表达式形式：接口名 对象名 = (形参)->{接口实现};

lambda表达式简化：

 public class Lambda {
 
     public static void main(String[] args) {
 
         Ilike i = (int a)->{        //lambda表达式
             System.out.println("Hello World"+a);
         };
         i.number(1);
         //简化1：去掉参数类型
         i = (a)->{
             System.out.println("Hello World"+a);
         };
         //简化2：去掉形参括号（有多个形参时不行）
         i = a->{
             System.out.println("Hello World"+a);
         };
         //简化3：去掉大括号（有多行实现代码时不行）
         i = a-> System.out.println("Hello World"+a);;
     }
 }
 interface Ilike {   //函数式接口
     void number(int a);
 }