Java多线程（上）

线程简介

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位
一个进程中可以包含若干个线程，线程是CPU，线程独立的执行路径
main()是主线程，系统的入口，用于执行整个程序
真正的多线程是多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点，CPU只能执行一个代码，因为切换的很快，所以有同时执行的错觉

线程创建

继承Thread类

//继承Thread类
public class TestThread extends Thread{
  //重写run()方法
  public void run(){
    for(int i=0; i<=10; i++){
      System.out.println("I am singing.");
    }
  }
  
  public static void main(String[] args){
    //main线程    
    //创建一个线程对象，调用start()
    //如果调用的是run()，就相当于调用一个方法，如上图
    TestThread testThread1 = mew TestThread();
    testThread1.start();
    
    for(int i = 0; i<20; i++){
      System.out.println("I am laughing.");
    }
  }
}

线程开启由CPU调度，不一定立即执行

实现Runnable接口

public class TestThread implements Runnable{
  public void run(){
    for(int i=0; i<=10; i++){
      System.out.println("I am singing.");
    }
  }
  
  public static void main(String[] args){
    TestThread testThread2 = new TestThread();
    //创建线程对象，通过线程对象来开启线程，代理
    Thread thread = new Thread(testThread2);
    thread.start();
    //new Thread(testThread2).start();
    
    for(int i = 0; i<20; i++){
      System.out.println("I am laughing.");
    }
  }
}

避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

模拟龟兔赛跑

public class Race implements Runnable{
  //胜利者
  private static String winner;
  
  public void run(){
    for(int i = 0; i<=100; i++){
      //判断比赛是否结束
      boolean flag = gameOver(i);
      if(flag){
        break;
      }
      System.out.println(Thread.currentThread.getName()+"-->跑了"+i+"步");
    }
  }
  //判断是否完成比赛
  private boolean gameOver(int steps){
    //判断是否有胜利者
    if(winner != null){
      return true;
    }{
      if(steps >= 100){
        winner = Thread.currentThread().getName();
        System.out.println("winner is"+winner);
        return true;
      }
    }
    return false;
  }
  
  public static void main(String[] args){
     Race race = new Race();
    new Thread(race,"rabbit").start();
    new Thread(race,"turtle").start();
  }
}

实现Callable接口（了解）

public class TestThread3 implements Callable<Boolean>{
  //Callable是有返回值的
  //重写call()方法 
  public Boolean call(){
    for(int i=0; i<=10; i++){
      System.out.println("I am singing.");
    }
    return true;
  }
  
  //Callable需要抛出异常
  public static void main(String[] args) throws ExecutionException, InterruptedException{
    TestThread3 testThread3 = new TestThread3();
    //创建执行服务,有几个线程括号里写几,线程池
    ExecutorService ser = Executors.newFixedThreadPool(1);
    //提交执行
    Future<Boolean> r1 = ser.submit(testThread3);
    //获取结果
    boolean rs1 = r1.get();
    //关闭服务
    ser.shutdownNow();
  }
}

Lamda表达式

为什么使用？

避免匿名内部类定义过多

可以让代码看起来简洁

去掉了一行没有意义的代码，只留下核心的逻辑

函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
```
public interface Run{
  public abstract void run();
}
```

对于函数式接口，可以通过Lamda表达式来创建该接口的对象

 public class TestLamda{
   //3. 静态内部类
   static void Like2 implements ILike{
     public void lamda(){
    	System.out.println("I like lamda2");
  	}
   }
   
   public static void main(String[] args){
     //实现2
     ILike like = new Like();
     like.lamda();
     
     //实现3
     like = new Like2();
     like.lamda();
     
     //4.局部内部类
     class Like3 implements ILike{
       public void lamda(){
         System.out.println("I like lamda3");
       }
     }
     like = new Like3();
     like.lamda();
     
     //5.匿名内部类
     like = new Like(){
       public void lamda(){
         System.out.println("I like lamda4");
       }
     };
     like.lamda();
     
     //6.Lamda表达式
    	like = ()->{
        System.out.println("I like lamda5");
      };
     like.lamda();
          
   }
 }

//1.定义一个函数式接口
interface ILike{
  void lamda();
}

//2.实现类
class Like implements ILike{
  public void lamda(){
    System.out.println("I like lamda");
  }
}

 public class TestLamda2{
   public static void main(String[] args){
     love = (int a)->{
       System.out.println("I love you -->" + a);
     };
     //简化一：去掉参数类型
     /*
     多个参数类型也可以去掉，要去掉都去掉，必须加上括号
     */ 
     love = (a)->{
       System.out.println("I love you -->" + a);
     };
     //简化二：简化括号
     love = a ->{
       System.out.println("I love you -->" + a);
     };
     //简化三：简化花括号
     	/*
			能去掉花括号因为里面的代码只有一行
			*/
     love = a -> System.out.println("I love you -->" + a);
      
     love.love(520);
   }
 }

interface ILove{
  void love(int a);
}

静态代理

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情

public class StaticProxy{
  public static void main(String[] args){
    
    new Thread( ()->System.out.println("520520") ).start();
    
    WeddingCompany weddingCompany = new WeddingCompany(new You());
    weddingCompany.HappyMarry();
  }
}

interface Marry{
  public void HappyMarry();
}

//真实对象
class You implements Marry{
  public void HappyMarry(){
    System.out.println("Happy Marry!");
  }
}

//代理角色，帮你结婚
class WeddingCompany implements Marry{
  //代理谁-->真实目标角色
  private Marry target;
  public WeddingCompany(Marry target){
    this.target = target;
  }
  
  public void HappyMarry(){
    before();
    this.target.HappyMarry();
    after();
  }
  private void before(){
    System.out.println("Before Marry!");
  }
  private void after(){
    System.out.println("After Marry!");
  }
}

posted @ 2021-02-18 12:52 GladysChloe 阅读(27) 评论(0) 收藏举报

刷新页面返回顶部

GladysChloe

Java多线程（上）

线程简介

线程创建

模拟龟兔赛跑

Lamda表达式

为什么使用？

函数式接口

静态代理

公告