Java多线程详解——Part one

线程、进程、多进程

• 程序：静态

• 进程：动态

• 线程：进程的单元，每个进程都有至少一个线程

  线程是独立执行的路径

---

线程创建

三种创建方式

• 继承Tread类（重点）
  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
• 实现Runnable接口（重点）
  1. 定义类实现Runnable接口
  2. 实现run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程

当多个线程同时操作同一个对象的时候，会产生资源调度的问题，可能同一个资源被不同的对象同时拿到，造成资源分配紊乱，就好比如抢票，如果同一时间好多人同时抢票，如果没有特殊的机制进行资源分配，运用实现Runnable接口的方法会出现一张票被好几个人抢到的现象

• 实现Callable接口（了解）
  1. 实现Callable接口，需要返回值类型
  2. 重回写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务
  5. 提交执行
  6. 获取结果
  7. 关闭服务

线程开始不一定立即执行，由cpu调度

---

Lamda表达式

属于函数式编程地概念

好处：

1. 避免匿名内部类定义过多
2. 去掉没有意义的代码，让代码看起来更简洁

函数式接口：只包含唯一一个抽象方法，就称为函数式接口

• 对于函数式接口，我们可以通过lamda表达式来创建接口的对象

public class Lambda {
    //静态内部类
    static class test2 implements lamb{
        public void print2(int a,double b){
            System.out.println(a);
        }
    }


    public static void main(String[] args) {
        //局部内部类
        class test3 implements lamb{
            public void print3(int a,double b){
                System.out.println(a);
            }
        }

        lamb lam = new test1();
        lam.print(5,2);

        lam = new test2();
        lam.print(3,2);
        
        lam = new test3();
        lam.print(9,2);

        //匿名内部类
        lam = new lamb(){
            public void print(int a,double b){
                System.out.println(a);
            }
        };
        lam.print(9,2);

        //lambda表达式(函数参数类型可以省略，并且要省略就要全部都省略)
        lam = (int a,double b)-> System.out.println(a);
        lam.print(10,2);
    }
}

//函数式接口
interface lamb{
    void print(int a,double b);
}

class test1 implements lamb{
    public void print1(int a,double b){
        System.out.println(a);
    }
}

---

线程状态

1. new 新生状态
2. 就绪状态
3. 运行状态
4. 阻塞状态
5. dead 死亡状态

---

• 停止线程

  1. 建议线程正常停止------利用次数
  2. 建议使用标志位------设置一个标志位
  3. 不要使用stop或者destroy等过时或者jdk不建议使用的方法

  //例子
  public class TestDead implements Runnable {
      //创建标志位
      private boolean flag = true;
  
      //重写run方法
      public void run(){
          int i = 0;
          while(this.flag){
              System.out.println("run....."+i++);
          }
      }
  
      //写一个供外部调用的停止run方法的方法
      public void stop(){
          this.flag = false;
      }
  
  
      //测试
      public static void main(String[] args) {
          TestDead testDead = new TestDead();
          new Thread(testDead).start();
  
          for (int i = 0; i < 1000; i++) {
              System.out.println("main"+i);
              if(i==900){
                  testDead.stop();
                  System.out.println("线程结束了");
              }
          }
      }
  }
  

• 线程休眠

  sleep(时间) 指定当前线程阻塞的毫秒数

  sleep存在异常InterruptedException

  sleep可以模拟网络延时，倒计时等

  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  //时间更新
  public class TestSleep {
      //时间更新测试
      public static void main(String[] args) {
          //获取线程当前时间（开始时间）
          Date starttime = new Date(System.currentTimeMillis());
  
          while(true){
              try {
                  Thread.sleep(1000);
                  //格式化打印当前时间
                  System.out.println(new SimpleDateFormat("HH:mm:ss").format(starttime));
                  //更新当前时间
                  starttime = new Date(System.currentTimeMillis());
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
  
          }
      }
  

• 线程礼让

  Thread.yield();

  让当前正在执行的线程暂停，但是不阻塞

  将线程从运行状态转为就绪状态

• 线程合并

  Join合并线程，待此线程执行完成后，其他线程得以继续

  可以想象为插队

  public class TestJoin implements Runnable{
      @Override
      public void run() {
          for (int i = 0; i < 100; i++) {
              System.out.println(i+"VIP来了");
          }
      }
  
      public static void main(String[] args) throws InterruptedException {
          TestJoin testJoin = new TestJoin();
          Thread thread = new Thread(testJoin);
          thread.start();
  
          for (int i = 0; i < 1000; i++) {
              //当主线程执行到10次的时候，强行插入vip线程，直到vip线程执行完再继续主线程
              if(i==10){
                  thread.join();
              }
              System.out.println(i+"mian方法来了");
          }
          
      }
  }