Java基础2

线程

 

Java基础实现方式：

 

实现Java基础方式一：继承Thread类【应用】

• 方法介绍

  方法名	说明
  void run()	在线程开启后，此方法将被调用执行
  void start()	使此线程开始执行，Java虚拟机会调用run方法()

• 实现步骤

  • 定义一个类MyThread继承Thread类

  • 在MyThread类中重写run()方法

  • 创建MyThread类的对象

  • 启动线程

• 代码演示

   public class MyThread extends Thread {
       @Override
       public void run() {
           for(int i=0; i<100; i++) {
               System.out.println(i);
           }
       }
   }
   public class MyThreadDemo {
       public static void main(String[] args) {
           MyThread my1 = new MyThread();
           MyThread my2 = new MyThread();
   ​
   //        my1.run();
   //        my2.run();
   ​
           //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
           my1.start();
           my2.start();
       }
   }

• 两个小问题

  • 为什么要重写run()方法？

    因为run()是用来封装被线程执行的代码

  • run()方法和start()方法的区别？

    run()：封装线程执行的代码，直接调用，相当于普通方法的调用

    start()：启动线程；然后由JVM调用此线程的run()方法

实现Java基础方式二：实现Runnable接口【应用】

• Thread构造方法

  方法名	说明
  Thread(Runnable target)	分配一个新的Thread对象
  Thread(Runnable target, String name)	分配一个新的Thread对象

• 实现步骤

  • 定义一个类MyRunnable实现Runnable接口

  • 在MyRunnable类中重写run()方法

  • 创建MyRunnable类的对象

  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数

  • 启动线程

• 代码演示

   public class MyRunnable implements Runnable {
       @Override
       public void run() {
           for(int i=0; i<100; i++) {
               System.out.println(Thread.currentThread().getName()+":"+i);
           }
       }
   }
   public class MyRunnableDemo {
       public static void main(String[] args) {
           //创建MyRunnable类的对象
           MyRunnable my = new MyRunnable();
   ​
           //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
           //Thread(Runnable target)
   //        Thread t1 = new Thread(my);
   //        Thread t2 = new Thread(my);
           //Thread(Runnable target, String name)
           Thread t1 = new Thread(my,"坦克");
           Thread t2 = new Thread(my,"飞机");
   ​
           //启动线程
           t1.start();
           t2.start();
       }
   }

实现Java基础方式三: 实现Callable接口【应用】

• 方法介绍

  方法名	说明
  V call()	计算结果，如果无法计算结果，则抛出一个异常
  FutureTask(Callable<V> callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
  V get()	如有必要，等待计算完成，然后获取其结果

• 实现步骤

  • 定义一个类MyCallable实现Callable接口

  • 在MyCallable类中重写call()方法

  • 创建MyCallable类的对象

  • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

  • 创建Thread类的对象，把FutureTask对象作为构造方法的参数

  • 启动线程

  • 再调用get方法，就可以获取线程结束之后的结果。

• 代码演示

   public class MyCallable implements Callable<String> {
       @Override
       public String call() throws Exception {
           for (int i = 0; i < 100; i++) {
               System.out.println("跟女孩表白" + i);
           }
           //返回值就表示线程运行完毕之后的结果
           return "答应";
       }
   }
   public class Demo {
       public static void main(String[] args) throws ExecutionException, InterruptedException {
           //线程开启之后需要执行里面的call方法
           MyCallable mc = new MyCallable();
   ​
           //Thread t1 = new Thread(mc);
   ​
           //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
           FutureTask<String> ft = new FutureTask<>(mc);
   ​
           //创建线程对象
           Thread t1 = new Thread(ft);
   ​
           String s = ft.get();
           //开启线程
           t1.start();
   ​
           //String s = ft.get();
           System.out.println(s);
       }
   }

• 三种实现方式的对比

  • 实现Runnable、Callable接口

    • 好处: 扩展性强，实现该接口的同时还可以继承其他的类

    • 缺点: 编程相对复杂，不能直接使用Thread类中的方法

  • 继承Thread类

    • 好处: 编程比较简单，可以直接使用Thread类中的方法

    • 缺点: 可以扩展性较差，不能再继承其他的类

设置和获取线程名称【应用】

• 方法介绍

  方法名	说明
  void setName(String name)	将此线程的名称更改为等于参数name
  String getName()	返回此线程的名称
  Thread currentThread()	返回对当前正在执行的线程对象的引用

线程休眠【应用】

• 相关方法

  方法名	说明
  static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数

线程优先级【应用】

• 线程调度

  • 两种调度方式

    • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

    • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

  • Java使用的是抢占式调度模型

  • 随机性

    假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说Java基础程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

• 优先级相关方法

  方法名	说明
  final int getPriority()	返回此线程的优先级
  final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

守护线程【应用】

• 相关方法

  方法名	说明
  void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

2.线程同步

同步代码块解决数据安全问题【应用】

• 安全问题出现的条件

  • 是Java基础环境

  • 有共享数据

  • 有多条语句操作共享数据

• 如何解决Java基础安全问题呢?

  • 基本思想：让程序没有安全问题的环境

• 怎么实现呢?

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

  • Java提供了同步代码块的方式来解决

• 同步代码块格式：

   synchronized(任意对象) { 
       多条语句操作共享数据的代码 
   }

  synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

• 同步的好处和弊端

  • 好处：解决了Java基础的数据安全问题

  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

同步方法解决数据安全问题【应用】

• 同步方法的格式

  同步方法：就是把synchronized关键字加到方法上

   修饰符 synchronized 返回值类型 方法名(方法参数) { 
       方法体；
   }

  同步方法的锁对象是什么呢?

  this

• 静态同步方法

  同步静态方法：就是把synchronized关键字加到静态方法上

   修饰符 static synchronized 返回值类型 方法名(方法参数) { 
       方法体；
   }

  同步静态方法的锁对象是什么呢?

  类名.class

死锁【理解】

• 概述

  线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

• 什么情况下会产生死锁

  1. 资源有限

  2. 同步嵌套

• 代码演示

   public class Demo {
       public static void main(String[] args) {
           Object objA = new Object();
           Object objB = new Object();
   ​
           new Thread(()->{
               while(true){
                   synchronized (objA){
                       //线程一
                       synchronized (objB){
                           System.out.println("小康同学正在走路");
                       }
                   }
               }
           }).start();
   ​
           new Thread(()->{
               while(true){
                   synchronized (objB){
                       //线程二
                       synchronized (objA){
                           System.out.println("小薇同学正在走路");
                       }
                   }
               }
           }).start();
       }
   }

3.生产者消费者

3.1生产者和消费者模式概述【应用】

• 概述

  生产者消费者模式是一个十分经典的Java基础协作的模式，弄懂生产者消费者问题能够让我们对Java基础编程的理解更加深刻。

  所谓生产者消费者问题，实际上主要是包含了两类线程：

  一类是生产者线程用于生产数据

  一类是消费者线程用于消费数据

  为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

  生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

  消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

• Object类的等待和唤醒方法

  方法名	说明
  void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
  void notify()	唤醒正在等待对象监视器的单个线程
  void notifyAll()	唤醒正在等待对象监视器的所有线程

3.2生产者和消费者案例【应用】

• 案例需求

  • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量

  • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

    1.判断是否有包子,决定当前线程是否执行

    2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子

    3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子

  • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

    1.判断是否有包子,决定当前线程是否执行

    2.如果没有包子,就进入等待状态,如果有包子,就消费包子

    3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子

  • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

    创建生产者线程和消费者线程对象

    分别开启两个线程

• 代码实现

   public class Desk {
   ​
       //定义一个标记
       //true 就表示桌子上有汉堡包的,此时允许吃货执行
       //false 就表示桌子上没有汉堡包的,此时允许厨师执行
       public static boolean flag = false;
   ​
       //汉堡包的总数量
       public static int count = 10;
   ​
       //锁对象
       public static final Object lock = new Object();
   }
   ​
   public class Cooker extends Thread {
   //    生产者步骤：
   //            1，判断桌子上是否有汉堡包
   //    如果有就等待，如果没有才生产。
   //            2，把汉堡包放在桌子上。
   //            3，叫醒等待的消费者开吃。
       @Override
       public void run() {
           while(true){
               synchronized (Desk.lock){
                   if(Desk.count == 0){
                       break;
                   }else{
                       if(!Desk.flag){
                           //生产
                           System.out.println("厨师正在生产汉堡包");
                           Desk.flag = true;
                           Desk.lock.notifyAll();
                       }else{
                           try {
                               Desk.lock.wait();
                           } catch (InterruptedException e) {
                               e.printStackTrace();
                           }
                       }
                   }
               }
           }
       }
   }
   ​
   public class Foodie extends Thread {
       @Override
       public void run() {
   //        1，判断桌子上是否有汉堡包。
   //        2，如果没有就等待。
   //        3，如果有就开吃
   //        4，吃完之后，桌子上的汉堡包就没有了
   //                叫醒等待的生产者继续生产
   //        汉堡包的总数量减一
   ​
           //套路:
               //1. while(true)死循环
               //2. synchronized 锁,锁对象要唯一
               //3. 判断,共享数据是否结束. 结束
               //4. 判断,共享数据是否结束. 没有结束
           while(true){
               synchronized (Desk.lock){
                   if(Desk.count == 0){
                       break;
                   }else{
                       if(Desk.flag){
                           //有
                           System.out.println("吃货在吃汉堡包");
                           Desk.flag = false;
                           Desk.lock.notifyAll();
                           Desk.count--;
                       }else{
                           //没有就等待
                           //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                           try {
                               Desk.lock.wait();
                           } catch (InterruptedException e) {
                               e.printStackTrace();
                           }
                       }
                   }
               }
           }
   ​
       }
   }
   ​
   public class Demo {
       public static void main(String[] args) {
           /*消费者步骤：
           1，判断桌子上是否有汉堡包。
           2，如果没有就等待。
           3，如果有就开吃
           4，吃完之后，桌子上的汉堡包就没有了
                   叫醒等待的生产者继续生产
           汉堡包的总数量减一*/
   ​
           /*生产者步骤：
           1，判断桌子上是否有汉堡包
           如果有就等待，如果没有才生产。
           2，把汉堡包放在桌子上。
           3，叫醒等待的消费者开吃。*/
   ​
           Foodie f = new Foodie();
           Cooker c = new Cooker();
   ​
           f.start();
           c.start();
   ​
       }
   }

3.3生产者和消费者案例优化【应用】

• 需求

  • 将Desk类中的变量,采用面向对象的方式封装起来

  • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用

  • 创建生产者和消费者线程对象,构造方法中传入Desk类对象

  • 开启两个线程

• 代码实现

  public class Desk {
  
      //定义一个标记
      //true 就表示桌子上有汉堡包的,此时允许吃货执行
      //false 就表示桌子上没有汉堡包的,此时允许厨师执行
      //public static boolean flag = false;
      private boolean flag;
  
      //汉堡包的总数量
      //public static int count = 10;
      //以后我们在使用这种必须有默认值的变量
     // private int count = 10;
      private int count;
  
      //锁对象
      //public static final Object lock = new Object();
      private final Object lock = new Object();
  
      public Desk() {
          this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
      }
  
      public Desk(boolean flag, int count) {
          this.flag = flag;
          this.count = count;
      }
  
      public boolean isFlag() {
          return flag;
      }
  
      public void setFlag(boolean flag) {
          this.flag = flag;
      }
  
      public int getCount() {
          return count;
      }
  
      public void setCount(int count) {
          this.count = count;
      }
  
      public Object getLock() {
          return lock;
      }
  
      @Override
      public String toString() {
          return "Desk{" +
                  "flag=" + flag +
                  ", count=" + count +
                  ", lock=" + lock +
                  '}';
      }
  }
  
  public class Cooker extends Thread {
  
      private Desk desk;
  
      public Cooker(Desk desk) {
          this.desk = desk;
      }
  //    生产者步骤：
  //            1，判断桌子上是否有汉堡包
  //    如果有就等待，如果没有才生产。
  //            2，把汉堡包放在桌子上。
  //            3，叫醒等待的消费者开吃。
  
      @Override
      public void run() {
          while(true){
              synchronized (desk.getLock()){
                  if(desk.getCount() == 0){
                      break;
                  }else{
                      //System.out.println("验证一下是否执行了");
                      if(!desk.isFlag()){
                          //生产
                          System.out.println("厨师正在生产汉堡包");
                          desk.setFlag(true);
                          desk.getLock().notifyAll();
                      }else{
                          try {
                              desk.getLock().wait();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      }
                  }
              }
          }
      }
  }
  
  public class Foodie extends Thread {
      private Desk desk;
  
      public Foodie(Desk desk) {
          this.desk = desk;
      }
  
      @Override
      public void run() {
  //        1，判断桌子上是否有汉堡包。
  //        2，如果没有就等待。
  //        3，如果有就开吃
  //        4，吃完之后，桌子上的汉堡包就没有了
  //                叫醒等待的生产者继续生产
  //        汉堡包的总数量减一
  
          //套路:
              //1. while(true)死循环
              //2. synchronized 锁,锁对象要唯一
              //3. 判断,共享数据是否结束. 结束
              //4. 判断,共享数据是否结束. 没有结束
          while(true){
              synchronized (desk.getLock()){
                  if(desk.getCount() == 0){
                      break;
                  }else{
                      //System.out.println("验证一下是否执行了");
                      if(desk.isFlag()){
                          //有
                          System.out.println("吃货在吃汉堡包");
                          desk.setFlag(false);
                          desk.getLock().notifyAll();
                          desk.setCount(desk.getCount() - 1);
                      }else{
                          //没有就等待
                          //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                          try {
                              desk.getLock().wait();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      }
                  }
              }
          }
  
      }
  }
  
  public class Demo {
      public static void main(String[] args) {
          /*消费者步骤：
          1，判断桌子上是否有汉堡包。
          2，如果没有就等待。
          3，如果有就开吃
          4，吃完之后，桌子上的汉堡包就没有了
                  叫醒等待的生产者继续生产
          汉堡包的总数量减一*/
  
          /*生产者步骤：
          1，判断桌子上是否有汉堡包
          如果有就等待，如果没有才生产。
          2，把汉堡包放在桌子上。
          3，叫醒等待的消费者开吃。*/
  
          Desk desk = new Desk();
  
          Foodie f = new Foodie(desk);
          Cooker c = new Cooker(desk);
  
          f.start();
          c.start();
  
      }
  }
  

3.4阻塞队列基本使用【理解】

• 阻塞队列继承结构

• 常见BlockingQueue:

  ArrayBlockingQueue: 底层是数组,有界

  LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

• BlockingQueue的核心方法:

  put(anObject): 将参数放入队列,如果放不进去会阻塞

  take(): 取出第一个数据,取不到会阻塞

• 代码示例

  public class Demo02 {
      public static void main(String[] args) throws Exception {
          // 创建阻塞队列的对象,容量为 1
          ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
  
          // 存储元素
          arrayBlockingQueue.put("汉堡包");
  
          // 取元素
          System.out.println(arrayBlockingQueue.take());
          System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞
  
          System.out.println("程序结束了");
      }
  }
  

3.5阻塞队列实现等待唤醒机制【理解】

• 案例需求

  • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

    1.构造方法中接收一个阻塞队列对象

    2.在run方法中循环向阻塞队列中添加包子

    3.打印添加结果

  • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

    1.构造方法中接收一个阻塞队列对象

    2.在run方法中循环获取阻塞队列中的包子

    3.打印获取结果

  • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

    创建阻塞队列对象

    创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象

    分别开启两个线程

• 代码实现

  public class Cooker extends Thread {
  
      private ArrayBlockingQueue<String> bd;
  
      public Cooker(ArrayBlockingQueue<String> bd) {
          this.bd = bd;
      }
  //    生产者步骤：
  //            1，判断桌子上是否有汉堡包
  //    如果有就等待，如果没有才生产。
  //            2，把汉堡包放在桌子上。
  //            3，叫醒等待的消费者开吃。
  
      @Override
      public void run() {
          while (true) {
              try {
                  bd.put("汉堡包");
                  System.out.println("厨师放入一个汉堡包");
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }
  
  public class Foodie extends Thread {
      private ArrayBlockingQueue<String> bd;
  
      public Foodie(ArrayBlockingQueue<String> bd) {
          this.bd = bd;
      }
  
      @Override
      public void run() {
  //        1，判断桌子上是否有汉堡包。
  //        2，如果没有就等待。
  //        3，如果有就开吃
  //        4，吃完之后，桌子上的汉堡包就没有了
  //                叫醒等待的生产者继续生产
  //        汉堡包的总数量减一
  
          //套路:
          //1. while(true)死循环
          //2. synchronized 锁,锁对象要唯一
          //3. 判断,共享数据是否结束. 结束
          //4. 判断,共享数据是否结束. 没有结束
          while (true) {
              try {
                  String take = bd.take();
                  System.out.println("吃货将" + take + "拿出来吃了");
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
  
      }
  }
  
  public class Demo {
      public static void main(String[] args) {
          ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
  
          Foodie f = new Foodie(bd);
          Cooker c = new Cooker(bd);
  
          f.start();
          c.start();
      }
  }
  

1.线程池

1.1 线程状态介绍

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程

状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可运行状态 */
        RUNNABLE , 

        /* 阻塞状态 */
        BLOCKED , 

        /* 无限等待状态 */
        WAITING , 

        /* 计时等待 */
        TIMED_WAITING , 

        /* 终止 */
        TERMINATED;
    
	}
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：

 

1.2 线程池-基本原理

概述 :

线程池也是可以看做成一个池子，在该池子中存储很多个线程。

线程池存在的意义：

系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

线程池的设计思路 :

1. 准备一个任务容器

2. 一次性启动多个(2个)消费者线程

3. 刚开始任务容器是空的，所以线程都在wait

4. 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒

5. 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

1.3 线程池-Executors默认线程池

概述 : JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。

我们可以使用Executors中所提供的静态方法来创建线程池

static ExecutorService newCachedThreadPool() 创建一个默认的线程池 ​ static newFixedThreadPool(int nThreads) 创建一个指定最Java基础数量的线程池

代码实现 :

package com.itheima.mythreadpool;


//static ExecutorService newCachedThreadPool()   创建一个默认的线程池
//static newFixedThreadPool(int nThreads)	    创建一个指定最Java基础数量的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {

        //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 可以帮助我们创建线程池对象
        //ExecutorService --- 可以帮助我们控制线程池

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        //Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.shutdown();
    }
}

 

1.4 线程池-Executors创建指定上限的线程池

使用Executors中所提供的静态方法来创建线程池

static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最Java基础数量的线程池

代码实现 :

package com.itheima.mythreadpool;

//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最Java基础数量的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //参数不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        System.out.println(pool.getPoolSize());//2
//        executorService.shutdown();
    }
}

 

1.5 线程池-ThreadPoolExecutor

创建线程池对象 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

代码实现 :

package com.itheima.mythreadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位
//    参数五：任务队列
//    参数六：创建线程工厂
//    参数七：任务的拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

1.6 线程池-参数详解

 

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    
corePoolSize：   核心线程的最大值，不能小于0
maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
keepAliveTime：  空闲线程最大存活时间,不能小于0
unit：           时间单位
workQueue：      任务队列，不能为null
threadFactory：  创建线程工厂,不能为null      
handler：        任务的拒绝策略,不能为null  

 

1.7线程池-非默认任务拒绝策略

RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

ThreadPoolExecutor.AbortPolicy: 		    丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy： 		   丢弃任务，但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy：    抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy:        调用任务的run()方法绕过线程池直接执行。

注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数

案例演示1：演示ThreadPoolExecutor.AbortPolicy任务处理策略

public class ThreadPoolExecutorDemo01 {

    public static void main(String[] args) {

        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;

        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-3---->> 执行了任务

控制台报错，仅仅执行了4个任务，有一个任务被丢弃了

 

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;

        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务

控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了

 

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
            final int y = x ;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);
            });     
        }
    }
}

控制台输出结果

pool-1-thread-2---->> 执行了任务2
pool-1-thread-1---->> 执行了任务0
pool-1-thread-3---->> 执行了任务3
pool-1-thread-1---->> 执行了任务4

由于任务1在线程池中等待时间最长，因此任务1被丢弃。

 

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略

public class ThreadPoolExecutorDemo04 {
    public static void main(String[] args) {

        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());

        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-1---->> 执行了任务
main---->> 执行了任务

通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。

2. 原子性

2.1 volatile-问题

代码分析 :

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();
    }
}

public class Money {
    public static int money = 100000;
}

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("结婚基金已经不是十万了");
    }
}

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Money.money = 90000;
    }
}

程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。

 

2.2 volatile解决

以上案例出现的问题 :

当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

1，堆内存是唯一的，每一个线程都有自己的线程栈。

2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

3 ，在线程中，每一次使用是从变量的副本中获取的。

Volatile关键字 : 强制线程每次在使用的时候，都会看一下共享区域最新的值

代码实现 : 使用volatile关键字解决

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();
    }
}

public class Money {
    public static volatile int money = 100000;
}

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(Money.money == 100000){

        }

        System.out.println("结婚基金已经不是十万了");
    }
}

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Money.money = 90000;
    }
}

 

2.3 synchronized解决

synchronized解决 :

1 ，线程获得锁

2 ，清空变量副本

3 ，拷贝共享变量最新的值到变量副本中

4 ，执行代码

5 ，将修改后变量副本中的值赋值给共享数据

6 ，释放锁

代码实现 :

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();
    }
}

public class Money {
    public static Object lock = new Object();
    public static volatile int money = 100000;
}

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(true){
            synchronized (Money.lock){
                if(Money.money != 100000){
                    System.out.println("结婚基金已经不是十万了");
                    break;
                }
            }
        }
    }
}

public class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Money.money = 90000;
        }
    }
}

 

2.4 原子性

概述 : 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

代码实现 :

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}

代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

 

2.5 volatile关键字不能保证原子性

解决方案 : 我们可以给count++操作添加锁，那么count++操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量
    private Object lock = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            synchronized (lock) {
                count++;
                System.out.println("已经送了" + count + "个冰淇淋");
            }
        }
    }
}

 

2.6 原子性_AtomicInteger

概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变

量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解

使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

AtomicBoolean： 原子更新布尔类型

AtomicInteger： 原子更新整型

AtomicLong： 原子更新长整型

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

public AtomicInteger()：	   			    初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)：  初始化一个指定值的原子型Integer

int get():   			 				获取值
int getAndIncrement():      			 以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():     				 以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data):				 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):   			 以原子方式设置为newValue的值，并返回旧值。

代码实现 :

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：	               初始化一个默认值为0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }

}

import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
//    int get():   		 		获取值
//    int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
//    int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
//    int addAndGet(int data):	 以原子方式将参数与对象中的值相加，并返回结果。
//    int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());

//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());

//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增后的值
//        System.out.println(ac3.get());

//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());

        AtomicInteger ac5 = new AtomicInteger(100);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());
    }
}

 

2.7 AtomicInteger-内存解析

AtomicInteger原理 : 自旋锁 + CAS 算法

CAS算法：

有3个操作数（内存值V， 旧的预期值A，要修改的值B）

当旧的预期值A == 内存值 此时修改成功，将V改为B

当旧的预期值A！=内存值 此时修改失败，不做任何操作

并重新获取现在的最新值（这个重新获取的动作就是自旋）

2.8 AtomicInteger-源码解析

代码实现 :

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable {
    //private volatile int count = 0; //送冰淇淋的数量
    //private Object lock = new Object();
    AtomicInteger ac = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            //synchronized (lock) {
//                count++;
//                ac++;
            int count = ac.incrementAndGet();
            System.out.println("已经送了" + count + "个冰淇淋");
           // }
        }
    }
}

源码解析 :

//先自增，然后获取自增后的结果
public final int incrementAndGet() {
        //+ 1 自增后的结果
        //this 就表示当前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}

public final int getAndAddInt(Object o, long offset, int delta) {
        //v 旧值
        int v;
        //自旋的过程
        do {
            //不断的获取旧值
            v = getIntVolatile(o, offset);
            //如果这个方法的返回值为false，那么继续自旋
            //如果这个方法的返回值为true，那么自旋结束
            //o 表示的就是内存值
            //v 旧值
            //v + delta 修改后的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
            //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
            //如果修改失败，那么继续自旋。
        return v;
}

 

2.9 悲观锁和乐观锁

synchronized和CAS的区别 :

相同点：在Java基础情况下，都可以保证共享数据的安全性。

不同点：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）

cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。

如果别人修改过，那么我再次获取现在最新的值。

如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）

 

3. 并发工具类

3.1 并发工具类-Hashtable

Hashtable出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(Java基础环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

代码实现 :

import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

 

3.2 并发工具类-ConcurrentHashMap基本使用

ConcurrentHashMap出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(Java基础环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

体系结构 :

总结 :

1 ，HashMap是线程不安全的。Java基础环境下会有数据安全问题

2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下

3，ConcurrentHashMap也是线程安全的，效率较高。 在JDK7和JDK8中，底层原理不一样。

代码实现 :

import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
    }
}

 

3.3 并发工具类-ConcurrentHashMap1.7原理

3.4 并发工具类-ConcurrentHashMap1.8原理

总结 :

1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表

2，计算当前元素应存入的索引。

3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。

4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。

5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证Java基础操作集合时数据的安全性

3.5 并发工具类-CountDownLatch

CountDownLatch类 :

方法	解释
public CountDownLatch(int count)	参数传递线程数，表示等待线程数量
public void await()	让线程等待
public void countDown()	当前线程执行完毕

使用场景： 让某一条线程等待其他线程执行完毕之后再执行

代码实现 :

import java.util.concurrent.CountDownLatch;

public class ChileThread1 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

import java.util.concurrent.CountDownLatch;

public class ChileThread2 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

import java.util.concurrent.CountDownLatch;

public class ChileThread3 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

import java.util.concurrent.CountDownLatch;

public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.等待
        try {
            //当计数器变成0的时候，会自动唤醒这里等待的线程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
    }
}

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.创建CountDownLatch的对象，需要传递给四个线程。
        //在底层就定义了一个计数器，此时计数器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.创建四个线程对象并开启他们。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();

        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");

        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小红");

        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小刚");

        t1.start();
        t2.start();
        t3.start();
    }
}

总结 :

1. CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。

2. await()：让线程等待，当计数器为0时，会唤醒等待的线程

3. countDown()： 线程执行完毕时调用，会将计数器-1。

3.6 并发工具类-Semaphore

使用场景 :

可以控制访问特定资源的线程数量。

实现步骤 :

1，需要有人管理这个通道

2，当有车进来了，发通行许可证

3，当车出去了，收回通行许可证

4，如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable {
    //1.获得管理员对象，
    private Semaphore semaphore = new Semaphore(2);
    @Override
    public void run() {
        //2.获得通行证
        try {
            semaphore.acquire();
            //3.开始行驶
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
            //4.归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

 

 

 

网络编程

1 介绍

• UD协议

  • 用户数据报协议(User Datagram Protocol)

  • UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

  • 由于使用UDP协议消耗系统资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输

  • 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

• TCP协议

  • 传输控制协议 (Transmission Control Protocol)

  • TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”

  • 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠

    第一次握手，客户端向服务器端发出连接请求，等待服务器确认

    第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求

    第三次握手，客户端再次向服务器端发送确认信息，确认连接

  • 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

2.UDP通信程序

2.1 UDP发送数据【应用】

• Java中的UDP通信

  • UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念

  • Java提供了DatagramSocket类作为基于UDP协议的Socket

• 构造方法

  方法名	说明
  DatagramSocket()	创建数据报套接字并将其绑定到本机地址上的任何可用端口
  DatagramPacket(byte[] buf,int len,InetAddress add,int port)	创建数据包,发送长度为len的数据包到指定主机的指定端口

• 相关方法

  方法名	说明
  void send(DatagramPacket p)	发送数据报包
  void close()	关闭数据报套接字
  void receive(DatagramPacket p)	从此套接字接受数据报包

• 发送数据的步骤

  • 创建发送端的Socket对象(DatagramSocket)

  • 创建数据，并把数据打包

  • 调用DatagramSocket对象的方法发送数据

  • 关闭发送端

• 代码演示

  public class SendDemo {
      public static void main(String[] args) throws IOException {
          //创建发送端的Socket对象(DatagramSocket)
          // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
          DatagramSocket ds = new DatagramSocket();
  
          //创建数据，并把数据打包
          //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
          //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
          byte[] bys = "hello,udp,我来了".getBytes();
  
          DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("127.0.0.1"),10086);
  
          //调用DatagramSocket对象的方法发送数据
          //void send(DatagramPacket p) 从此套接字发送数据报包
          ds.send(dp);
  
          //关闭发送端
          //void close() 关闭此数据报套接字
          ds.close();
      }
  }
  

2.2UDP接收数据【应用】

• 接收数据的步骤

  • 创建接收端的Socket对象(DatagramSocket)

  • 创建一个数据包，用于接收数据

  • 调用DatagramSocket对象的方法接收数据

  • 解析数据包，并把数据在控制台显示

  • 关闭接收端

• 构造方法

  方法名	说明
  DatagramPacket(byte[] buf, int len)	创建一个DatagramPacket用于接收长度为len的数据包

• 相关方法

  方法名	说明
  byte[] getData()	返回数据缓冲区
  int getLength()	返回要发送的数据的长度或接收的数据的长度

• 示例代码

  public class ReceiveDemo {
      public static void main(String[] args) throws IOException {
        	//创建接收端的Socket对象(DatagramSocket)
        	DatagramSocket ds = new DatagramSocket(12345);
  
        	//创建一个数据包，用于接收数据
        	byte[] bys = new byte[1024];
        	DatagramPacket dp = new DatagramPacket(bys, bys.length);
  
        	//调用DatagramSocket对象的方法接收数据
        	ds.receive(dp);
  
        	//解析数据包，并把数据在控制台显示
        	System.out.println("数据是：" + new String(dp.getData(), 0,                                             dp.getLength()));
          }
      }
  }
  

2.3UDP通信程序练习【应用】

• 案例需求

  UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

  UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

• 代码实现

  /*
      UDP发送数据：
          数据来自于键盘录入，直到输入的数据是886，发送数据结束
   */
  public class SendDemo {
      public static void main(String[] args) throws IOException {
          //创建发送端的Socket对象(DatagramSocket)
          DatagramSocket ds = new DatagramSocket();
          //键盘录入数据
          Scanner sc = new Scanner(System.in);
          while (true) {
            	String s = sc.nextLine();
              //输入的数据是886，发送数据结束
              if ("886".equals(s)) {
                  break;
              }
              //创建数据，并把数据打包
              byte[] bys = s.getBytes();
              DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);
  
              //调用DatagramSocket对象的方法发送数据
              ds.send(dp);
          }
          //关闭发送端
          ds.close();
      }
  }
  
  /*
      UDP接收数据：
          因为接收端不知道发送端什么时候停止发送，故采用死循环接收
   */
  public class ReceiveDemo {
      public static void main(String[] args) throws IOException {
          //创建接收端的Socket对象(DatagramSocket)
          DatagramSocket ds = new DatagramSocket(12345);
          while (true) {
              //创建一个数据包，用于接收数据
              byte[] bys = new byte[1024];
              DatagramPacket dp = new DatagramPacket(bys, bys.length);
              //调用DatagramSocket对象的方法接收数据
              ds.receive(dp);
              //解析数据包，并把数据在控制台显示
              System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
          }
          //关闭接收端
  //        ds.close();
      }
  }
  

2.4UDP三种通讯方式【理解】

• 单播

  单播用于两个主机之间的端对端通信

• 组播

  组播用于对一组特定的主机进行通信

• 广播

  广播用于一个主机对整个局域网上所有主机上的数据通信

2.5UDP组播实现【理解】

• 实现步骤

  • 发送端

    1. 创建发送端的Socket对象(DatagramSocket)

    2. 创建数据，并把数据打包(DatagramPacket)

    3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)

    4. 释放资源

  • 接收端

    1. 创建接收端Socket对象(MulticastSocket)

    2. 创建一个箱子,用于接收数据

    3. 把当前计算机绑定一个组播地址

    4. 将数据接收到箱子中

    5. 解析数据包,并打印数据

    6. 释放资源

• 代码实现

  // 发送端
  public class ClinetDemo {
      public static void main(String[] args) throws IOException {
          // 1. 创建发送端的Socket对象(DatagramSocket)
          DatagramSocket ds = new DatagramSocket();
          String s = "hello 组播";
          byte[] bytes = s.getBytes();
          InetAddress address = InetAddress.getByName("224.0.1.0");
          int port = 10000;
          // 2. 创建数据，并把数据打包(DatagramPacket)
          DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
          // 3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
          ds.send(dp);
          // 4. 释放资源
          ds.close();
      }
  }
  // 接收端
  public class ServerDemo {
      public static void main(String[] args) throws IOException {
          // 1. 创建接收端Socket对象(MulticastSocket)
          MulticastSocket ms = new MulticastSocket(10000);
          // 2. 创建一个箱子,用于接收数据
          DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
          // 3. 把当前计算机绑定一个组播地址,表示添加到这一组中.
          ms.joinGroup(InetAddress.getByName("224.0.1.0"));
          // 4. 将数据接收到箱子中
          ms.receive(dp);
          // 5. 解析数据包,并打印数据
          byte[] data = dp.getData();
          int length = dp.getLength();
          System.out.println(new String(data,0,length));
          // 6. 释放资源
          ms.close();
      }
  }
  

2.6UDP广播实现【理解】

• 实现步骤

  • 发送端

    1. 创建发送端Socket对象(DatagramSocket)

    2. 创建存储数据的箱子,将广播地址封装进去

    3. 发送数据

    4. 释放资源

  • 接收端

    1. 创建接收端的Socket对象(DatagramSocket)

    2. 创建一个数据包，用于接收数据

    3. 调用DatagramSocket对象的方法接收数据

    4. 解析数据包，并把数据在控制台显示

    5. 关闭接收端

• 代码实现

  // 发送端
  public class ClientDemo {
      public static void main(String[] args) throws IOException {
        	// 1. 创建发送端Socket对象(DatagramSocket)
          DatagramSocket ds = new DatagramSocket();
  		// 2. 创建存储数据的箱子,将广播地址封装进去
          String s = "广播 hello";
          byte[] bytes = s.getBytes();
          InetAddress address = InetAddress.getByName("255.255.255.255");
          int port = 10000;
          DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
  		// 3. 发送数据
          ds.send(dp);
  		// 4. 释放资源
          ds.close();
      }
  }
  // 接收端
  public class ServerDemo {
      public static void main(String[] args) throws IOException {
          // 1. 创建接收端的Socket对象(DatagramSocket)
          DatagramSocket ds = new DatagramSocket(10000);
          // 2. 创建一个数据包，用于接收数据
          DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
          // 3. 调用DatagramSocket对象的方法接收数据
          ds.receive(dp);
          // 4. 解析数据包，并把数据在控制台显示
          byte[] data = dp.getData();
          int length = dp.getLength();
          System.out.println(new String(data,0,length));
          // 5. 关闭接收端
          ds.close();
      }
  }
  

3.TCP通信程序

3.1TCP发送数据【应用】

• Java中的TCP通信

  • Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。

  • Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

• 构造方法

  方法名	说明
  Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
  Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号

• 相关方法

  方法名	说明
  InputStream getInputStream()	返回此套接字的输入流
  OutputStream getOutputStream()	返回此套接字的输出流

• 示例代码

  public class ClientDemo {
      public static void main(String[] args) throws IOException {
          //创建客户端的Socket对象(Socket)
          //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
          Socket s = new Socket("127.0.0.1",10000);
  
          //获取输出流，写数据
          //OutputStream getOutputStream() 返回此套接字的输出流
          OutputStream os = s.getOutputStream();
          os.write("hello,tcp,我来了".getBytes());
  
          //释放资源
          s.close();
      }
  }
  

3.2TCP接收数据【应用】

• 构造方法

  方法名	说明
  ServletSocket(int port)	创建绑定到指定端口的服务器套接字

• 相关方法

  方法名	说明
  Socket accept()	监听要连接到此的套接字并接受它

• 注意事项

  1. accept方法是阻塞的,作用就是等待客户端连接

  2. 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接

  3. 针对客户端来讲,是往外写的,所以是输出流 针对服务器来讲,是往里读的,所以是输入流

  4. read方法也是阻塞的

  5. 客户端在关流的时候,还多了一个往服务器写结束标记的动作

  6. 最后一步断开连接,通过四次挥手协议保证连接终止

• 三次握手和四次挥手

  • 三次握手

  • 四次挥手

• 示例代码

  public class ServerDemo {
      public static void main(String[] args) throws IOException {
          //创建服务器端的Socket对象(ServerSocket)
          //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
          ServerSocket ss = new ServerSocket(10000);
  
          //Socket accept() 侦听要连接到此套接字并接受它
          Socket s = ss.accept();
  
          //获取输入流，读数据，并把数据显示在控制台
          InputStream is = s.getInputStream();
          byte[] bys = new byte[1024];
          int len = is.read(bys);
          String data = new String(bys,0,len);
          System.out.println("数据是：" + data);
  
          //释放资源
          s.close();
          ss.close();
      }
  }
  

3.3TCP程序练习【应用】

• 案例需求

  客户端：发送数据，接受服务器反馈

  服务器：收到消息后给出反馈

• 案例分析

  • 客户端创建对象，使用输出流输出数据

  • 服务端创建对象，使用输入流接受数据

  • 服务端使用输出流给出反馈数据

  • 客户端使用输入流接受反馈数据

• 代码实现

  // 客户端
  public class ClientDemo {
      public static void main(String[] args) throws IOException {
          Socket socket = new Socket("127.0.0.1",10000);
  
          OutputStream os = socket.getOutputStream();
          os.write("hello".getBytes());
         // os.close();如果在这里关流,会导致整个socket都无法使用
          socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
          
          BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
          String line;
          while((line = br.readLine())!=null){
              System.out.println(line);
          }
          br.close();
          os.close();
          socket.close();
      }
  }
  // 服务器
  public class ServerDemo {
      public static void main(String[] args) throws IOException {
          ServerSocket ss = new ServerSocket(10000);
  
          Socket accept = ss.accept();
  
          InputStream is = accept.getInputStream();
          int b;
          while((b = is.read())!=-1){
              System.out.println((char) b);
          }
  
          System.out.println("看看我执行了吗?");
  
          BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
          bw.write("你谁啊?");
          bw.newLine();
          bw.flush();
  
          bw.close();
          is.close();
          accept.close();
          ss.close();
      }
  }
  

3.4TCP程序文件上传练习【应用】

• 案例需求

  客户端：数据来自于本地文件，接收服务器反馈

  服务器：接收到的数据写入本地文件，给出反馈

• 案例分析

  • 创建客户端对象，创建输入流对象指向文件，每读一次数据就给服务器输出一次数据，输出结束后使用shutdownOutput()方法告知服务端传输结束

  • 创建服务器对象，创建输出流对象指向文件，每接受一次数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息

  • 客户端接受服务端的回馈信息

• 相关方法

  方法名	说明
  void shutdownInput()	将此套接字的输入流放置在“流的末尾”
  void shutdownOutput()	禁止用此套接字的输出流

• 代码实现

  // 客户端
  public class ClientDemo {
      public static void main(String[] args) throws IOException {
          Socket socket = new Socket("127.0.0.1",10000);
  
          //是本地的流,用来读取本地文件的.
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("socketmodule\\ClientDir\\1.jpg"));
  
          //写到服务器 --- 网络中的流
          OutputStream os = socket.getOutputStream();
          BufferedOutputStream bos = new BufferedOutputStream(os);
  
          int b;
          while((b = bis.read())!=-1){
              bos.write(b);//通过网络写到服务器中
          }
          bos.flush();
          //给服务器一个结束标记,告诉服务器文件已经传输完毕
          socket.shutdownOutput();
  
          BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
          String line;
          while((line = br.readLine()) !=null){
              System.out.println(line);
          }
          bis.close();
          socket.close();
      }
  }
  // 服务器
  public class ServerDemo {
      public static void main(String[] args) throws IOException {
          ServerSocket ss = new ServerSocket(10000);
  
          Socket accept = ss.accept();
  
          //网络中的流,从客户端读取数据的
          BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
          //本地的IO流,把数据写到本地中,实现永久化存储
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("socketmodule\\ServerDir\\copy.jpg"));
  
          int b;
          while((b = bis.read()) !=-1){
              bos.write(b);
          }
  
          BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
          bw.write("上传成功");
          bw.newLine();
          bw.flush();
  
          bos.close();
          accept.close();
          ss.close();
      }
  }
  

3.5TCP程序服务器优化【应用】

• 优化方案一

  • 需求

    服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。

  • 解决方案

    使用循环

  • 代码实现

    // 服务器代码如下,客户端代码同上个案例,此处不再给出
    public class ServerDemo {
        public static void main(String[] args) throws IOException {
            ServerSocket ss = new ServerSocket(10000);
    
            while (true) {
                Socket accept = ss.accept();
    
                //网络中的流,从客户端读取数据的
                BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                //本地的IO流,把数据写到本地中,实现永久化存储
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\copy.jpg"));
    
                int b;
                while((b = bis.read()) !=-1){
                    bos.write(b);
                }
    
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                bw.write("上传成功");
                bw.newLine();
                bw.flush();
    
                bos.close();
                accept.close();
            }
            //ss.close();
            
        }
    }
    

• 优化方案二

  • 需求

    第二次上传文件的时候，会把第一次的文件给覆盖。

  • 解决方案

    UUID. randomUUID()方法生成随机的文件名

  • 代码实现

    // 服务器代码如下,客户端代码同上个案例,此处不再给出
    public class ServerDemo {
        public static void main(String[] args) throws IOException {
            ServerSocket ss = new ServerSocket(10000);
    
            while (true) {
                Socket accept = ss.accept();
    
                //网络中的流,从客户端读取数据的
                BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                //本地的IO流,把数据写到本地中,实现永久化存储
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));
    
                int b;
                while((b = bis.read()) !=-1){
                    bos.write(b);
                }
    
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                bw.write("上传成功");
                bw.newLine();
                bw.flush();
    
                bos.close();
                accept.close();
            }
            //ss.close();
    
        }
    }
    

• 优化方案三

  • 需求

    使用循环虽然可以让服务器处理多个客户端请求。但是还是无法同时跟多个客户端进行通信。

  • 解决方案

    开启Java基础处理

  • 代码实现

    // 线程任务类
    public class ThreadSocket implements Runnable {
        private Socket acceptSocket;
    
        public ThreadSocket(Socket accept) {
            this.acceptSocket = accept;
        }
      
        @Override
        public void run() {
            BufferedOutputStream bos = null;
            try {
                //网络中的流,从客户端读取数据的
                BufferedInputStream bis = new BufferedInputStream(acceptSocket.getInputStream());
                //本地的IO流,把数据写到本地中,实现永久化存储
                bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));
    
                int b;
                while((b = bis.read()) !=-1){
                    bos.write(b);
                }
              
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream()));
                bw.write("上传成功");
                bw.newLine();
                bw.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(bos != null){
                    try {
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                if (acceptSocket != null){
                    try {
                        acceptSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    // 服务器代码
    public class ServerDemo {
        public static void main(String[] args) throws IOException {
            ServerSocket ss = new ServerSocket(10000);
    
            while (true) {
                Socket accept = ss.accept();
                ThreadSocket ts = new ThreadSocket(accept);
                new Thread(ts).start();
            }
            //ss.close();
        }
    }
    

• 优化方案四

  • 需求

    使用Java基础虽然可以让服务器同时处理多个客户端请求。但是资源消耗太大。

  • 解决方案

    加入线程池

  • 代码实现

    // 服务器代码如下,线程任务类代码同上,此处不再给出
    public class ServerDemo {
        public static void main(String[] args) throws IOException {
            ServerSocket ss = new ServerSocket(10000);
            ThreadPoolExecutor pool = new ThreadPoolExecutor(
                    3,//核心线程数量
                    10,   //线程池的总数量
                    60,   //临时线程空闲时间
                    TimeUnit.SECONDS, //临时线程空闲时间的单位
                    new ArrayBlockingQueue<>(5),//阻塞队列
                    Executors.defaultThreadFactory(),//创建线程的方式
                    new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
            );
    
            while (true) {
                Socket accept = ss.accept();
                ThreadSocket ts = new ThreadSocket(accept);
                //new Thread(ts).start();
                pool.submit(ts);
            }
            //ss.close();
        }
    }
    

##

UDP格式

TCP格式

发送：

接收：

 

HTTP协议

请求信息

• 组成

  • 请求行

  • 请求头

  • 请求空行

  • 请求体

• 请求行

  • 格式

  • 请求方式

    GET,POST,HEAD,PUT,DELETE,CONNECT,OPTIONS,TRACE,PATCH

    其中用的比较多的是GET和POST

  • URI

    请求资源路径,统一资源标识符

  • 协议版本

    • HTTP1.0: 每次请求和响应都需要建立一个单独的连接

    • HTTP1.1:支持长连接

• 请求头

  • 格式

  • 请求头名称

    • Host: 用来指定请求的服务端地址

    • Connection: 取值为keep-alive表示需要持久连接

    • User-Agent: 客户端的信息

    • Accept: 指定客户端能够接收的内容类型

    • Accept-Encoding: 指定浏览器可以支持的服务器返回内容压缩编码类型

    • Accept-Language: 浏览器可接受的语言

• 小结

响应信息

• 组成

  • 响应行

  • 响应头

  • 响应空行

  • 响应体

• 响应行

  • 格式

  • 协议版本

    • HTTP1.0: 每次请求和响应都需要建立一个单独的连接

    • HTTP1.1: 支持长连接

  • 响应状态码

    • 1xx: 指示信息(表示请求已接收，继续处理)

    • 2xx: 成功(表示请求已被成功接收、理解、接受)

    • 3xx: 请求重定向(要完成请求必须进行更进一步的操作)

    • 4xx: 客户端错误(请求有语法错误或请求无法实现)

    • 5xx: 服务器端错误(服务器未能实现合法的请求)

  • 状态信息

    • 200 ok

    • 404 Not Found

    • 500 Internal Server Error

• 响应头

  • 响应头名称

    • Content-Type: 告诉客户端实际返回内容的网络媒体类型(互联网媒体类型,也叫做MIME类型)

  • 响应头值

    • text/html ----> 文本类型

    • image/png ----> png格式文件

    • image/jpeg ----> jpg格式文件

• 小结

HTTP服务器

3.1需求【理解】

• 编写服务器端代码,实现可以解析浏览器的请求,给浏览器响应数据

3.2环境搭建【理解】

• 实现步骤

  • 编写HttpServer类,实现可以接收浏览器发出的请求

  • 其中获取连接的代码可以单独抽取到一个类中

• 代码实现

  // 服务端代码
  public class HttpServer {
      public static void main(String[] args) throws IOException {
          //1.打开服务端通道
          ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
          //2.让这个通道绑定一个端口
          serverSocketChannel.bind(new InetSocketAddress(10000));
          //3.设置通道为非阻塞
          serverSocketChannel.configureBlocking(false);
          //4.打开一个选择器
          Selector selector = Selector.open();
  
          //5.绑定选择器和服务端通道
          serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  
          while(true){
              //6.选择器会监视通道的状态.
              int count = selector.select();
              if(count != 0){
                  //7.会遍历所有的服务端通道.看谁准备好了,谁准备好了,就让谁去连接.
                  //获取所有服务端通道的令牌,并将它们都放到一个集合中,将集合返回.
                  Set<SelectionKey> selectionKeys = selector.selectedKeys();
                  Iterator<SelectionKey> iterator = selectionKeys.iterator();
                  while(iterator.hasNext()){
                      //selectionKey 依次表示每一个服务端通道的令牌
                      SelectionKey selectionKey = iterator.next();
                      if(selectionKey.isAcceptable()){
                          //获取连接
                          AcceptHandler acceptHandler = new AcceptHandler();
                          acceptHandler.connSocketChannel(selectionKey);
                      }else if(selectionKey.isReadable()){
                         
                      }
                      //任务处理完毕以后,将SelectionKey从集合中移除
                      iterator.remove();
                  }
              }
          }
      }
  }
  // 将获取连接的代码抽取到这个类中
  public class AcceptHandler {
  
      public SocketChannel connSocketChannel(SelectionKey selectionKey){
          try {
              //获取到已经就绪的服务端通道
              ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
              SocketChannel socketChannel = ssc.accept();
              //设置为非阻塞状态
              socketChannel.configureBlocking(false);
              //把socketChannel注册到选择器上
              socketChannel.register(selectionKey.selector(), SelectionKey.OP_READ);
              return socketChannel;
          } catch (IOException e) {
              e.printStackTrace();
          }
          return null;
      }
  }
  

3.3获取请求信息并解析【理解】

• 实现步骤

  • 将请求信息封装到HttpRequest类中

  • 在类中定义方法,实现获取请求信息并解析

• 代码实现

  /**
   * 用来封装请求数据的类
   */
  public class HttpRequest {
      private String method; //请求方式
      private String requestURI; //请求的uri
      private String version;   //http的协议版本
  
      private HashMap<String,String> hm = new HashMap<>();//所有的请求头
  
      //parse --- 获取请求数据 并解析
      public void parse(SelectionKey selectionKey){
          try {
              SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
  
              StringBuilder sb = new StringBuilder();
              //创建一个缓冲区
              ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
              int len;
              //循环读取
              while((len = socketChannel.read(byteBuffer)) > 0){
                  byteBuffer.flip();
                  sb.append(new String(byteBuffer.array(),0,len));
                  //System.out.println(new String(byteBuffer.array(),0,len));
                  byteBuffer.clear();
              }
              //System.out.println(sb);
              parseHttpRequest(sb);
  
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      //解析http请求协议中的数据
      private void parseHttpRequest(StringBuilder sb) {
          //1.需要把StringBuilder先变成一个字符串
          String httpRequestStr = sb.toString();
          //2.获取每一行数据
          String[] split = httpRequestStr.split("\r\n");
          //3.获取请求行
          String httpRequestLine = split[0];//GET / HTTP/1.1
          //4.按照空格进行切割,得到请求行中的三部分
          String[] httpRequestInfo = httpRequestLine.split(" ");
          this.method = httpRequestInfo[0];
          this.requestURI = httpRequestInfo[1];
          this.version = httpRequestInfo[2];
          //5.操作每一个请求头
          for (int i = 1; i < split.length; i++) {
              String httpRequestHeaderInfo = split[i];//Host: 127.0.0.1:10000
              String[] httpRequestHeaderInfoArr = httpRequestHeaderInfo.split(": ");
              hm.put(httpRequestHeaderInfoArr[0],httpRequestHeaderInfoArr[1]);
          }
  
      }
  
      public String getMethod() {
          return method;
      }
  
      public void setMethod(String method) {
          this.method = method;
      }
  
      public String getRequestURI() {
          return requestURI;
      }
  
      public void setRequestURI(String requestURI) {
          this.requestURI = requestURI;
      }
  
      public String getVersion() {
          return version;
      }
  
      public void setVersion(String version) {
          this.version = version;
      }
  
      public HashMap<String, String> getHm() {
          return hm;
      }
  
      public void setHm(HashMap<String, String> hm) {
          this.hm = hm;
      }
  
      @Override
      public String toString() {
          return "HttpRequest{" +
                  "method='" + method + '\'' +
                  ", requestURI='" + requestURI + '\'' +
                  ", version='" + version + '\'' +
                  ", hm=" + hm +
                  '}';
      }
  }
  

3.4给浏览器响应数据【理解】

• 实现步骤

  • 将响应信息封装HttpResponse类中

  • 定义方法,封装响应信息,给浏览器响应数据

• 代码实现

  public class HttpResponse {
      private String version; //协议版本
      private String status;  //响应状态码
      private String desc;    //状态码的描述信息
  
      //响应头数据
      private HashMap<String, String> hm = new HashMap<>();
  
      private HttpRequest httpRequest;  //我们后面要根据请求的数据,来进行一些判断
  
      //给浏览器响应数据的方法
      public void sendStaticResource(SelectionKey selectionKey) {
          //1.给响应行赋值
          this.version = "HTTP/1.1";
          this.status = "200";
          this.desc = "ok";
          //2.将响应行拼接成一个单独的字符串 // HTTP/1.1 200 ok
          String responseLine = this.version + " " + this.status + " " + this.desc + "\r\n";
  
          //3.给响应头赋值
          hm.put("Content-Type", "text/html;charset=UTF-8");
  
          //4.将所有的响应头拼接成一个单独的字符串
          StringBuilder sb = new StringBuilder();
          Set<Map.Entry<String, String>> entries = hm.entrySet();
          for (Map.Entry<String, String> entry : entries) {
              sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
          }
  
          //5.响应空行
          String emptyLine = "\r\n";
  
          //6.响应行,响应头,响应空行拼接成一个大字符串
          String responseLineStr = responseLine + sb.toString() + emptyLine;
  
          try {
              //7.将上面三个写给浏览器
              SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
              ByteBuffer byteBuffer1 = ByteBuffer.wrap(responseLineStr.getBytes());
              socketChannel.write(byteBuffer1);
  
              //8.单独操作响应体
              //因为在以后响应体不一定是一个字符串
              //有可能是一个文件,所以单独操作
              String s = "哎哟,妈呀,终于写完了.";
              ByteBuffer byteBuffer2 = ByteBuffer.wrap(s.getBytes());
              socketChannel.write(byteBuffer2);
  
              //9.释放资源
              socketChannel.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      public String getVersion() {
          return version;
      }
  
      public void setVersion(String version) {
          this.version = version;
      }
  
      public String getStatus() {
          return status;
      }
  
      public void setStatus(String status) {
          this.status = status;
      }
  
      public String getDesc() {
          return desc;
      }
  
      public void setDesc(String desc) {
          this.desc = desc;
      }
  
      public HashMap<String, String> getHm() {
          return hm;
      }
  
      public void setHm(HashMap<String, String> hm) {
          this.hm = hm;
      }
  
      public HttpRequest getHttpRequest() {
          return httpRequest;
      }
  
      public void setHttpRequest(HttpRequest httpRequest) {
          this.httpRequest = httpRequest;
      }
  
      @Override
      public String toString() {
          return "HttpResponse{" +
                  "version='" + version + '\'' +
                  ", status='" + status + '\'' +
                  ", desc='" + desc + '\'' +
                  ", hm=" + hm +
                  ", httpRequest=" + httpRequest +
                  '}';
      }
  }
  

3.5代码优化【理解】

• 实现步骤

  • 根据请求资源路径不同,响应不同的数据

  • 服务端健壮性处理

  • 访问不存在的资源处理

• 代码实现

  /**
   * 接收连接的任务处理类
   */
  public class AcceptHandler {
  
      public SocketChannel connSocketChannel(SelectionKey selectionKey){
          try {
              //获取到已经就绪的服务端通道
              ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
              SocketChannel socketChannel = ssc.accept();
              //设置为非阻塞状态
              socketChannel.configureBlocking(false);
              //把socketChannel注册到选择器上
              socketChannel.register(selectionKey.selector(), SelectionKey.OP_READ);
              return socketChannel;
          } catch (IOException e) {
              e.printStackTrace();
          }
          return null;
      }
  }
  /**
   * 接收客户端请求的类
   */
  public class HttpServer {
      public static void main(String[] args) throws IOException {
          //1.打开服务端通道
          ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
          //2.让这个通道绑定一个端口
          serverSocketChannel.bind(new InetSocketAddress(10000));
          //3.设置通道为非阻塞
          serverSocketChannel.configureBlocking(false);
          //4.打开一个选择器
          Selector selector = Selector.open();
          //5.绑定选择器和服务端通道
          serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  
          while(true){
              //6.选择器会监视通道的状态.
              int count = selector.select();
              if(count != 0){
                  //7.会遍历所有的服务端通道.看谁准备好了,谁准备好了,就让谁去连接.
                  //获取所有服务端通道的令牌,并将它们都放到一个集合中,将集合返回.
                  Set<SelectionKey> selectionKeys = selector.selectedKeys();
                  Iterator<SelectionKey> iterator = selectionKeys.iterator();
                  while(iterator.hasNext()){
                      //selectionKey 依次表示每一个服务端通道的令牌
                      SelectionKey selectionKey = iterator.next();
                      if(selectionKey.isAcceptable()){
                          //获取连接
                          AcceptHandler acceptHandler = new AcceptHandler();
                          acceptHandler.connSocketChannel(selectionKey);
  
                      }else if(selectionKey.isReadable()){
                          //读取数据
                          HttpRequest httpRequest = new HttpRequest();
                          httpRequest.parse(selectionKey);
                          System.out.println("http请求的数据为 ---->" + httpRequest);
  
                          if(httpRequest.getRequestURI() == null || "".equals(httpRequest.getRequestURI())){
                              selectionKey.channel();
                              continue;
                          }
                          System.out.println("...数据解析完毕,准备响应数据....");
  
                          //响应数据
                          HttpResponse httpResponse = new HttpResponse();
                          httpResponse.setHttpRequest(httpRequest);
                          httpResponse.sendStaticResource(selectionKey);
                      }
                      //任务处理完毕以后,将SelectionKey从集合中移除
                      iterator.remove();
                  }
              }
          }
      }
  }
  /**
   * 用来封装请求数据的类
   */
  public class HttpRequest {
      private String method; //请求方式
      private String requestURI; //请求的uri
      private String version;   //http的协议版本
  
      private HashMap<String,String> hm = new HashMap<>();//所有的请求头
  
      //parse --- 获取请求数据 并解析
      public void parse(SelectionKey selectionKey){
          try {
              SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
  
              StringBuilder sb = new StringBuilder();
              //创建一个缓冲区
              ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
              int len;
              //循环读取
              while((len = socketChannel.read(byteBuffer)) > 0){
                  byteBuffer.flip();
                  sb.append(new String(byteBuffer.array(),0,len));
                  //System.out.println(new String(byteBuffer.array(),0,len));
                  byteBuffer.clear();
              }
              //System.out.println(sb);
              parseHttpRequest(sb);
  
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
    
      //解析http请求协议中的数据
      private void parseHttpRequest(StringBuilder sb) {
          //1.需要把StringBuilder先变成一个字符串
          String httpRequestStr = sb.toString();
          if(!(httpRequestStr == null || "".equals(httpRequestStr))){
              //2.获取每一行数据
              String[] split = httpRequestStr.split("\r\n");
              //3.获取请求行
              String httpRequestLine = split[0];//GET / HTTP/1.1
              //4.按照空格进行切割,得到请求行中的三部分
              String[] httpRequestInfo = httpRequestLine.split(" ");
              this.method = httpRequestInfo[0];
              this.requestURI = httpRequestInfo[1];
              this.version = httpRequestInfo[2];
              //5.操作每一个请求头
              for (int i = 1; i < split.length; i++) {
                  String httpRequestHeaderInfo = split[i];//Host: 127.0.0.1:10000
                  String[] httpRequestHeaderInfoArr = httpRequestHeaderInfo.split(": ");
                  hm.put(httpRequestHeaderInfoArr[0],httpRequestHeaderInfoArr[1]);
              }
          }
      }
  
      public String getMethod() {
          return method;
      }
  
      public void setMethod(String method) {
          this.method = method;
      }
  
      public String getRequestURI() {
          return requestURI;
      }
  
      public void setRequestURI(String requestURI) {
          this.requestURI = requestURI;
      }
  
      public String getVersion() {
          return version;
      }
  
      public void setVersion(String version) {
          this.version = version;
      }
  
      public HashMap<String, String> getHm() {
          return hm;
      }
  
      public void setHm(HashMap<String, String> hm) {
          this.hm = hm;
      }
  
      @Override
      public String toString() {
          return "HttpRequest{" +
                  "method='" + method + '\'' +
                  ", requestURI='" + requestURI + '\'' +
                  ", version='" + version + '\'' +
                  ", hm=" + hm +
                  '}';
      }
  }
  /**
   * 用来封装响应数据的类
   */
  public class HttpResponse {
      private String version; //协议版本
      private String status;  //响应状态码
      private String desc;    //状态码的描述信息
  
      //响应头数据
      private HashMap<String, String> hm = new HashMap<>();
  
      private HttpRequest httpRequest;  //我们后面要根据请求的数据,来进行一些判断
  
      //给浏览器响应数据的方法
      public void sendStaticResource(SelectionKey selectionKey) {
          //1.给响应行赋值
          this.version = "HTTP/1.1";
          this.status = "200";
          this.desc = "ok";
  
          //3.给响应头赋值
          //先获取浏览器请求的URI
          String requestURI = this.getHttpRequest().getRequestURI();
          if(requestURI != null){
  
              File file = new File(WEB_APP_PATH + requestURI);
              //判断这个路径是否存在
              if(!file.exists()){
                  this.status = "404";
                  this.desc = "NOT FOUNG";
              }
  
              if("200".equals(this.status)){
                  if("/".equals(requestURI)){
                      hm.put("Content-Type", "text/html;charset=UTF-8");
                  }else if("/favicon.ico".equals(requestURI)){
                      hm.put("Content-Type", "image/x-icon");
                  }else if("/a.txt".equals(requestURI)){
                      hm.put("Content-Type", "text/html;charset=UTF-8");
                  }else if("/1.jpg".equals(requestURI)){
                      hm.put("Content-Type", "image/jpeg");
                  }else if("/1.png".equals(requestURI)){
                      hm.put("Content-Type", "image/png");
                  }
              }else{
                  hm.put("Content-Type", "text/html;charset=UTF-8");
              }
  
          }
  
          //2.将响应行拼接成一个单独的字符串 // HTTP/1.1 200 ok
          String responseLine = this.version + " " + this.status + " " + this.desc + "\r\n";
  
          //4.将所有的响应头拼接成一个单独的字符串
          StringBuilder sb = new StringBuilder();
          Set<Map.Entry<String, String>> entries = hm.entrySet();
          for (Map.Entry<String, String> entry : entries) {
              sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
          }
  
          //5.响应空行
          String emptyLine = "\r\n";
  
          //6.响应行,响应头,响应空行拼接成一个大字符串
          String responseLineStr = responseLine + sb.toString() + emptyLine;
  
          try {
              //7.将上面三个写给浏览器
              SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
              ByteBuffer byteBuffer1 = ByteBuffer.wrap(responseLineStr.getBytes());
              socketChannel.write(byteBuffer1);
  
              //8.单独操作响应体
              //因为在以后响应体不一定是一个字符串
              //有可能是一个文件,所以单独操作
             // String s = "哎哟,妈呀,终于写完了.";
              byte [] bytes = getContent();
              ByteBuffer byteBuffer2 = ByteBuffer.wrap(bytes);
              socketChannel.write(byteBuffer2);
  
              //9.释放资源
              socketChannel.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      public static final String WEB_APP_PATH = "mynio\\webapp";
      private byte[] getContent() {
          try {
              //1.获取浏览器请求的URI
              String requestURI = this.getHttpRequest().getRequestURI();
              if(requestURI != null){
  
                  if("200".equals(this.status)){
                      //2.判断一下请求的URI,根据不同的URI来响应不同的东西
                      if("/".equals(requestURI)){
                          String s = "哎哟,妈呀,终于写完了.";
                          return s.getBytes();
                      }else/* if("/favicon.ico".equals(requestURI))*/{
                          //获取一个ico文件
                          FileInputStream fis = new FileInputStream(WEB_APP_PATH + requestURI);
                          //把ico文件变成一个字节数组返回
                          return IOUtils.toByteArray(fis);
                      }
                  }else{
                      return "访问的资源不存在".getBytes();
                  }
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
          return new byte[0];
      }
  
      public String getVersion() {
          return version;
      }
  
      public void setVersion(String version) {
          this.version = version;
      }
  
      public String getStatus() {
          return status;
      }
  
      public void setStatus(String status) {
          this.status = status;
      }
  
      public String getDesc() {
          return desc;
      }
  
      public void setDesc(String desc) {
          this.desc = desc;
      }
  
      public HashMap<String, String> getHm() {
          return hm;
      }
  
      public void setHm(HashMap<String, String> hm) {
          this.hm = hm;
      }
  
      public HttpRequest getHttpRequest() {
          return httpRequest;
      }
  
      public void setHttpRequest(HttpRequest httpRequest) {
          this.httpRequest = httpRequest;
      }
  
      @Override
      public String toString() {
          return "HttpResponse{" +
                  "version='" + version + '\'' +
                  ", status='" + status + '\'' +
                  ", desc='" + desc + '\'' +
                  ", hm=" + hm +
                  ", httpRequest=" + httpRequest +
                  '}';
      }
  }
  

   

 

反射

1.类加载器

1.1类加载器

• 作用

  负责将.class文件（存储的物理文件）加载在到内存中

1.2类加载的过程

• 类加载时机

  • 创建类的实例（对象）

  • 调用类的类方法

  • 访问类或者接口的类变量，或者为该类变量赋值

  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

  • 初始化某个类的子类

  • 直接使用java.exe命令来运行某个主类

• 类加载过程

  1. 加载

     • 通过包名 + 类名，获取这个类，准备用流进行传输

     • 在这个类加载到内存中

     • 加载完毕创建一个class对象

  2. 链接

     • 验证

       确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全

       (文件中的信息是否符合虚拟机规范有没有安全隐患)

     • 准备

       负责为类的类变量（被static修饰的变量）分配内存，并设置默认初始化值

       (初始化静态变量)

     • 解析

       将类的二进制数据流中的符号引用替换为直接引用

       (本类中如果用到了其他类，此时就需要找到对应的类)

  3. 初始化

     根据程序员通过程序制定的主观计划去初始化类变量和其他资源

     (静态变量赋值以及初始化其他资源)

• 小结

  • 当一个类被使用的时候，才会加载到内存

  • 类加载的过程: 加载、验证、准备、解析、初始化

1.3类加载的分类

• 分类

  • Bootstrap class loader：虚拟机的内置类加载器，通常表示为null ，并且没有父null

  • Platform class loader：平台类加载器,负责加载JDK中一些特殊的模块

  • System class loader：系统类加载器,负责加载用户类路径上所指定的类库

• 类加载器的继承关系

  • System的父加载器为Platform

  • Platform的父加载器为Bootstrap

• 代码演示

  public class ClassLoaderDemo1 {
      public static void main(String[] args) {
          //获取系统类加载器
          ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
  
          //获取系统类加载器的父加载器 --- 平台类加载器
          ClassLoader classLoader1 = systemClassLoader.getParent();
  
          //获取平台类加载器的父加载器 --- 启动类加载器
          ClassLoader classLoader2 = classLoader1.getParent();
  
          System.out.println("系统类加载器" + systemClassLoader);
          System.out.println("平台类加载器" + classLoader1);
          System.out.println("启动类加载器" + classLoader2);
  
      }
  }
  

1.4双亲委派模型

• 介绍

  如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

1.5ClassLoader 中的两个方法

• 方法介绍

  方法名	说明
  public static ClassLoader getSystemClassLoader()	获取系统类加载器
  public InputStream getResourceAsStream(String name)	加载某一个资源文件

• 示例代码

  public class ClassLoaderDemo2 {
      public static void main(String[] args) throws IOException {
          //static ClassLoader getSystemClassLoader() 获取系统类加载器
          //InputStream getResourceAsStream(String name)  加载某一个资源文件
  
          //获取系统类加载器
          ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
  
          //利用加载器去加载一个指定的文件
          //参数：文件的路径（放在src的根目录下，默认去那里加载）
          //返回值：字节流。
          InputStream is = systemClassLoader.getResourceAsStream("prop.properties");
  
          Properties prop = new Properties();
          prop.load(is);
  
          System.out.println(prop);
  
          is.close();
      }
  }
  

2.反射

2.1反射的概述

• 反射机制

  是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意属性和方法； 这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

2.2获取Class类对象的三种方式

• 三种方式分类

  • 类名.class属性

  • 对象名.getClass()方法

  • Class.forName(全类名)方法

     

• 示例代码

  public class Student {
      private String name;
      private int age;
  
      public Student() {
      }
  
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  
      public void study(){
          System.out.println("学生在学习");
      }
  
      @Override
      public String toString() {
          return "Student{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  '}';
      }
  }
  public class ReflectDemo1 {
      public static void main(String[] args) throws ClassNotFoundException {
          //1.Class类中的静态方法forName("全类名")
              //全类名:包名 + 类名
          Class clazz = Class.forName("com.itheima.myreflect2.Student");
          System.out.println(clazz);
  
          //2.通过class属性来获取
          Class clazz2 = Student.class;
          System.out.println(clazz2);
  
          //3.利用对象的getClass方法来获取class对象
          //getClass方法是定义在Object类中.
          Student s = new Student();
          Class clazz3 = s.getClass();
          System.out.println(clazz3);
  
          System.out.println(clazz == clazz2);
          System.out.println(clazz2 == clazz3);
      }
  }
  

2.3反射获取构造方法并使用

2.3.1Class类获取构造方法对象的方法

• 方法介绍

  方法名	说明
  Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
  Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
  Constructor<T> getConstructor(Class<?>... parameterTypes)	返回单个公共构造方法对象
  Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)	返回单个构造方法对象

• 示例代码

  public class Student {
      private String name;
      private int age;
  
      //私有的有参构造方法
      private Student(String name) {
          System.out.println("name的值为:" + name);
          System.out.println("private...Student...有参构造方法");
      }
  
      //公共的无参构造方法
      public Student() {
          System.out.println("public...Student...无参构造方法");
      }
  
      //公共的有参构造方法
      public Student(String name, int age) {
          System.out.println("name的值为:" + name + "age的值为:" + age);
          System.out.println("public...Student...有参构造方法");
      }
  }
  public class ReflectDemo1 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
          //method1();
          //method2();
          //method3();
          //method4();
      }
  
      private static void method4() throws ClassNotFoundException, NoSuchMethodException {
          //        Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：
  //                                      返回单个构造方法对象
          //1.获取Class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
          Constructor constructor = clazz.getDeclaredConstructor(String.class);
          System.out.println(constructor);
      }
  
      private static void method3() throws ClassNotFoundException, NoSuchMethodException {
          //        Constructor<T> getConstructor(Class<?>... parameterTypes)：
  //                                      返回单个公共构造方法对象
          //1.获取Class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
          //小括号中,一定要跟构造方法的形参保持一致.
          Constructor constructor1 = clazz.getConstructor();
          System.out.println(constructor1);
  
          Constructor constructor2 = clazz.getConstructor(String.class, int.class);
          System.out.println(constructor2);
  
          //因为Student类中,没有只有一个int的构造,所以这里会报错.
          Constructor constructor3 = clazz.getConstructor(int.class);
          System.out.println(constructor3);
      }
  
      private static void method2() throws ClassNotFoundException {
          //        Constructor<?>[] getDeclaredConstructors()：
  //                                      返回所有构造方法对象的数组
          //1.获取Class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
  
          Constructor[] constructors = clazz.getDeclaredConstructors();
          for (Constructor constructor : constructors) {
              System.out.println(constructor);
          }
      }
  
      private static void method1() throws ClassNotFoundException {
          //        Constructor<?>[] getConstructors()：
  //                                      返回所有公共构造方法对象的数组
          //1.获取Class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
          Constructor[] constructors = clazz.getConstructors();
          for (Constructor constructor : constructors) {
              System.out.println(constructor);
          }
      }
  }
  

2.3.2Constructor类用于创建对象的方法

• 方法介绍

  方法名	说明
  T newInstance(Object...initargs)	根据指定的构造方法创建对象
  setAccessible(boolean flag)	设置为true,表示取消访问检查

• 示例代码

  // Student类同上一个示例,这里就不在重复提供了
  public class ReflectDemo2 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
          //T newInstance(Object... initargs)：根据指定的构造方法创建对象
          //method1();
          //method2();
          //method3();
          //method4();
  
      }
  
      private static void method4() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
          //获取一个私有的构造方法并创建对象
          //1.获取class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
  
          //2.获取一个私有化的构造方法.
          Constructor constructor = clazz.getDeclaredConstructor(String.class);
  
          //被private修饰的成员,不能直接使用的
          //如果用反射强行获取并使用,需要临时取消访问检查
          constructor.setAccessible(true);
  
          //3.直接创建对象
          Student student = (Student) constructor.newInstance("zhangsan");
  
          System.out.println(student);
      }
  
      private static void method3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
          //简写格式
          //1.获取class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
  
          //2.在Class类中,有一个newInstance方法,可以利用空参直接创建一个对象
          Student student = (Student) clazz.newInstance();//这个方法现在已经过时了,了解一下
  
          System.out.println(student);
      }
  
      private static void method2() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
          //1.获取class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
  
          //2.获取构造方法对象
          Constructor constructor = clazz.getConstructor();
  
          //3.利用空参来创建Student的对象
          Student student = (Student) constructor.newInstance();
  
          System.out.println(student);
      }
  
      private static void method1() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
          //1.获取class对象
          Class clazz = Class.forName("com.gyq.myreflect3.Student");
  
          //2.获取构造方法对象
          Constructor constructor = clazz.getConstructor(String.class, int.class);
  
          //3.利用newInstance创建Student的对象
          Student student = (Student) constructor.newInstance("zhangsan", 23);
  
          System.out.println(student);
      }
  }
  

2.3.3小结

• 获取class对象

  三种方式: Class.forName(“全类名”), 类名.class, 对象名.getClass()

• 获取里面的构造方法对象

  getConstructor (Class<?>... parameterTypes) getDeclaredConstructor (Class<?>... parameterTypes)

• 如果是public的，直接创建对象

  newInstance(Object... initargs)

• 如果是非public的，需要临时取消检查，然后再创建对象

  setAccessible(boolean) 暴力反射

2.4反射获取成员变量并使用

2.4.1Class类获取成员变量对象的方法

• 方法分类

  方法名	说明
  Field[] getFields()	返回所有公共成员变量对象的数组
  Field[] getDeclaredFields()	返回所有成员变量对象的数组
  Field getField(String name)	返回单个公共成员变量对象
  Field getDeclaredField(String name)	返回单个成员变量对象

• 示例代码

  public class Student {
  
      public String name;
  
      public int age;
  
      public String gender;
  
      private int money = 300;
  
      @Override
      public String toString() {
          return "Student{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  ", gender='" + gender + '\'' +
                  ", money=" + money +
                  '}';
      }
  }
  public class ReflectDemo1 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
         // method1();
          //method2();
          //method3();
          //method4();
  
      }
  
      private static void method4() throws ClassNotFoundException, NoSuchFieldException {
          //        Field getDeclaredField(String name)：返回单个成员变量对象
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
    
          //2.获取money成员变量
          Field field = clazz.getDeclaredField("money");
    
          //3.打印一下
          System.out.println(field);
      }
    
      private static void method3() throws ClassNotFoundException, NoSuchFieldException {
          //        Field getField(String name)：返回单个公共成员变量对象
          //想要获取的成员变量必须是真实存在的
          //且必须是public修饰的.
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
    
          //2.获取name这个成员变量
          //Field field = clazz.getField("name");
          //Field field = clazz.getField("name1");
          Field field = clazz.getField("money");
    
          //3.打印一下
          System.out.println(field);
      }
    
      private static void method2() throws ClassNotFoundException {
          //        Field[] getDeclaredFields()：返回所有成员变量对象的数组
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
    
          //2.获取所有的Field对象
          Field[] fields = clazz.getDeclaredFields();
    
          //3.遍历
          for (Field field : fields) {
              System.out.println(field);
          }
      }
    
      private static void method1() throws ClassNotFoundException {
          //        Field[] getFields()：返回所有公共成员变量对象的数组
    
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
    
          //2.获取Field对象.
          Field[] fields = clazz.getFields();
    
          //3.遍历
          for (Field field : fields) {
              System.out.println(field);
          }
      }
  }
  

2.4.2Field类用于给成员变量赋值的方法

• 方法介绍

  方法名	说明
  void set(Object obj, Object value)	赋值
  Object get(Object obj)	获取值

• 示例代码

  // Student类同上一个示例,这里就不在重复提供了
  public class ReflectDemo2 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
  //        Object get(Object obj) 返回由该 Field表示的字段在指定对象上的值。
          //method1();
          //method2();
  
      }
  
      private static void method2() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
          //2.获取成员变量Field的对象
          Field field = clazz.getDeclaredField("money");
  
          //3.取消一下访问检查
          field.setAccessible(true);
  
          //4.调用get方法来获取值
          //4.1创建一个对象
          Student student = (Student) clazz.newInstance();
          //4.2获取指定对象的money的值
          Object o = field.get(student);
  
          //5.打印一下
          System.out.println(o);
      }
  
      private static void method1() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
          //        void set(Object obj, Object value)：给obj对象的成员变量赋值为value
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
          //2.获取name这个Field对象
          Field field = clazz.getField("name");
  
          //3.利用set方法进行赋值.
          //3.1先创建一个Student对象
          Student student = (Student) clazz.newInstance();
          //3.2有了对象才可以给指定对象进行赋值
          field.set(student,"zhangsan");
  
          System.out.println(student);
      }
  }
  

2.5反射获取成员方法并使用

2.5.1Class类获取成员方法对象的方法

• 方法分类

  方法名	说明
  Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
  Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
  Method getMethod(String name, Class<?>... parameterTypes)	返回单个公共成员方法对象
  Method getDeclaredMethod(String name, Class<?>... parameterTypes)	返回单个成员方法对象

• 示例代码

  public class Student {
  
      //私有的，无参无返回值
      private void show() {
          System.out.println("私有的show方法，无参无返回值");
      }
  
      //公共的，无参无返回值
      public void function1() {
          System.out.println("function1方法，无参无返回值");
      }
  
      //公共的，有参无返回值
      public void function2(String name) {
          System.out.println("function2方法，有参无返回值,参数为" + name);
      }
  
      //公共的，无参有返回值
      public String function3() {
          System.out.println("function3方法，无参有返回值");
          return "aaa";
      }
  
      //公共的，有参有返回值
      public String function4(String name) {
          System.out.println("function4方法，有参有返回值,参数为" + name);
          return "aaa";
      }
  }
  public class ReflectDemo1 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
          //method1();
          //method2();
          //method3();
          //method4();
          //method5();
      }
  
      private static void method5() throws ClassNotFoundException, NoSuchMethodException {
          //        Method getDeclaredMethod(String name, Class<?>... parameterTypes)：
  //                                返回单个成员方法对象
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
          //2.获取一个成员方法show
          Method method = clazz.getDeclaredMethod("show");
          //3.打印一下
          System.out.println(method);
      }
    
      private static void method4() throws ClassNotFoundException, NoSuchMethodException {
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
          //2.获取一个有形参的方法function2
          Method method = clazz.getMethod("function2", String.class);
          //3.打印一下
          System.out.println(method);
      }
    
      private static void method3() throws ClassNotFoundException, NoSuchMethodException {
          //        Method getMethod(String name, Class<?>... parameterTypes) ：
  //                                返回单个公共成员方法对象
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
          //2.获取成员方法function1
          Method method1 = clazz.getMethod("function1");
          //3.打印一下
          System.out.println(method1);
      }
    
      private static void method2() throws ClassNotFoundException {
          //        Method[] getDeclaredMethods()：
  //                                返回所有成员方法对象的数组，不包括继承的
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
    
          //2.获取Method对象
          Method[] methods = clazz.getDeclaredMethods();
          //3.遍历一下数组
          for (Method method : methods) {
              System.out.println(method);
          }
      }
    
      private static void method1() throws ClassNotFoundException {
          //        Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
          //2.获取成员方法对象
          Method[] methods = clazz.getMethods();
          //3.遍历
          for (Method method : methods) {
              System.out.println(method);
          }
      }
  }
  

2.5.2Method类用于执行方法的方法

• 方法介绍

  方法名	说明
  Object invoke(Object obj, Object... args)	运行方法

  参数一: 用obj对象调用该方法

  参数二: 调用方法的传递的参数(如果没有就不写)

  返回值: 方法的返回值(如果没有就不写)

• 示例代码

  public class ReflectDemo2 {
      public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
  //        Object invoke(Object obj, Object... args)：运行方法
  //        参数一：用obj对象调用该方法
  //        参数二：调用方法的传递的参数（如果没有就不写）
  //        返回值：方法的返回值（如果没有就不写）
  
          //1.获取class对象
          Class clazz = Class.forName("com.itheima.myreflect5.Student");
          //2.获取里面的Method对象  function4
          Method method = clazz.getMethod("function4", String.class);
          //3.运行function4方法就可以了
          //3.1创建一个Student对象,当做方法的调用者
          Student student = (Student) clazz.newInstance();
          //3.2运行方法
          Object result = method.invoke(student, "zhangsan");
          //4.打印一下返回值
          System.out.println(result);
      }
  }
  

2.6小结

Servlet实现方式

Servlet关系图

Servlet生命周期