老卫带你学---leetcode刷题(43. 字符串相乘)

多线程

• Java多线程
• • 1. 进程与线程
  • 2. 多线程
  • • 1） 相关概念
    • 2) 多线程实现方式
    • • ①继承Thread类
      • ②实现Runnable接口
      • ③利用Callable接口和Future接口
      • ④ 比较优缺点
  • 3. Thread类 常用方法
  • 4. 线程安全
  • • 1) 同步代码块
    • 2) 同步方法
    • 3) Lock锁
  • 5. 等待唤醒机制（生产者和消费者）
  • • 1) 生产者
    • 2) 消费者
    • 测试：
    • 3) 等待唤醒 —— 阻塞队列方式
  • 6. 线程状态
  • 7. 线程池
  • • 自定义线程池

Java多线程

1. 进程与线程

线程：

• 线程是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。

• 生命周期：

进程：

• 进程是程序的基本执行实体。

2. 多线程

1） 相关概念

相关概念：

• 并发：在同一时刻，有多个指令在单个CPU上交替执行。
• 并行：在同一时刻，有多个指令在单个CPU上同时进行。

2) 多线程实现方式

①继承Thread类

多线程第一种实现方式：

• ①继承Thread类

• ②重写run方法

• ③创建子类的对象，并使用start()方法启动线程

• /**
   * @author .29.
   * @create 2023-10-17 16:21
   */
  public class extendThread {
      //1.自定义类，继承Thread类
      static class myThread extends Thread{
          //2.重写run方法，编写执行逻辑
          @Override
          public void run() {
              for(int i = 0;i < 100; ++i){
                  System.out.println("执行：" + getName());
              }
          }
      }
  
      public static void main(String[] args){
          //3. 实现Thread子类对象，使用start()启动线程
          myThread t1 = new myThread();
          myThread t2 = new myThread();
          t1.setName("线程1号");
          t2.setName("线程2号");
          t1.start();
          t2.start();
      }
  }
  

②实现Runnable接口

多线程第二种实现方式：

• ①自定义类，实现Runnable接口。
• ②重写接口中的run方法。
• ③实例化Runnable实现类
• ④以Runnable实现类对象为参数，创建Thread实例，开启线程。

public class implementsRunnable {
    //1.自定义类，实现Runnable接口
    static class myRun implements Runnable{
        //2.重写抽象方法
        @Override
        public void run() {
            //编写需要执行的程序
            for(int i = 0;i < 100; ++i){
                //获取当前执行的线程
                Thread t = Thread.currentThread();
                System.out.println("执行：" + t.getName());
            }

        }
    }

    public static void main(String[] args){
        //3.实例化Runnable实现类
        myRun mr = new myRun();

        //4.创建线程对象，使用start()启动线程
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        t1.start();
        t2.start();

    }
}

③利用Callable接口和Future接口

多线程第三种实现方式

• 特点： 可以获取到多线程运行的结果
• ①创建一个Callable接口的实现类
• ②重写Callable接口中的call方法（返回多线程执行的结果）
• ③创建Callable实现类对象（表示多线程要实现的任务）
• ④创建Future实现类FutureTask的对象（用于管理多线程运行的结果）
• ⑤创建Thread对象，并启动

/**
 * @author .29.
 * @create 2023-10-17 21:09
 */
public class implementsCallable {
    //1.创建Callable接口实现类，泛型指定返回的线程执行结果的类型
    static class myCall implements Callable<Integer>{
        //2.重写实现类方法
        @Override
        public Integer call() throws Exception {
            return 29;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.实例化Callable实现类
        myCall call = new myCall();
        //4.创建FutureTask对象，管理多线程执行结果
        FutureTask<Integer> ft = new FutureTask<>(call);
        //5.创建线程，并启动
        Thread t1 = new Thread(ft);
        t1.start();

        //获取多线程运行的结果
        int result = ft.get();
        System.out.println(result);
    }
}

④ 比较优缺点

3. Thread类 常用方法

常用的成员方法：

• String getName()：返回此线程名称

• void setName(String name)：修改此线程名称

• static Thread currentThread()：获取当前线程实例对象

• static void sleep(long time)：让线程休眠指定时间（单位:毫秒）

• setPriority(int newPriority)：设置线程的优先级

• final int getPriority()：获取此线程的优先级，线程默认的优先级为5，优先级范围1-10，数字越大，优先级越高。

• final void setDaemon(boolean on)：设置为守护线程，当其他的非守护线程执行完毕后，守护线程就没有存在的必要了，会陆续结束，不一定会执行完毕。

• public static void yield()：出让线程/礼让线程

• •     //1.自定义类，继承Thread类
        static class myThread extends Thread{
            //2.重写run方法，编写执行逻辑
            @Override
            public void run() {
                for(int i = 0;i < 100; ++i){
                    System.out.println("执行：" + getName());
                    //出让CPU的执行权，即出让线程
                    Thread.yield();
                }
            }
        }
    

• public static void join()：插入线程/插队线程，将此线程插入到当前线程之前，只有插入的线程执行完毕，当前线程才会执行。

4. 线程安全

1) 同步代码块

• 格式：

• • synchronized(锁对象){
        //操作共享数据的代码
    }
    

  • 锁对象：可以是任意一个对象，但需要对象是唯一的，使用的锁不一样，没意义。建议使用当前类的字节码文件对象：Xxx.class

• 特点：

• • ①锁默认是打开状态，有一个线程进去了，锁自动关闭。
  • ②里面的代码全部执行完毕，线程出来，锁自动打开。

2) 同步方法

• 同步方法 —— 将synchronized关键字加到方法上。

• 格式：

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

• 特点：

• • ①同步方法是锁住方法里面所有的代码。
  • ②锁对象不能自己指定
  • • 非静态方法的锁对象：this（当前方法的调用者）
    • 静态方法的锁对象：当前类的字节码文件对象（Xxx.class）

3) Lock锁

• 为了清晰表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
• Lock中提供了获取锁和释放锁的方法：
• • void lock()——获得锁
  • void unlock()——释放锁
• Lock是接口，获取Lock对象需要实例化Lock的实现类ReentrantLock：
• • ReentrantLock()——构造方法、创建一个ReentrantLock实例

注意： 为了保证锁的释放，当调用lock()获得锁后，后面执行的代码放入到try{}catch{}块中，之后在finally{}块中调用unLock()，因为finally块中代码一定会执行，也就保证了锁一定会被释放。

5. 等待唤醒机制（生产者和消费者）

常用方法：

• void wait()：当前线程等待，直至被其他线程唤醒
• void notify()：随机唤醒单个线程
• void notifyAll()：唤醒所有线程

1) 生产者

生产者 代码：

/**
 * @author .29.
 * @create 2023-10-18 21:18
 */
//继承Thread
public class Producer extends Thread{
    //重写run方法
    @Override
    public void run() {
        //1.循环
        while(true){
            //2. 同步代码块
            synchronized(Product.lock){
                if(Product.count == 0){
                    break;
                }else{
                    if(Product.flag == 0){ //货架没有商品
                        System.out.println("生产者生产商品"); //生产
                        Product.flag = 1;                   //上架（修改状态）
                        Product.lock.notifyAll();           //唤醒与锁绑定的所有线程

                    }else{
                        try {
                            Product.lock.wait(); //货架有商品，等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
            }
        }
    }
}

商品货架:

/**
 * @author .29.
 * @create 2023-10-18 21:20
 */
public class Product {
    //总个数
    public static int count = 10;
    //消费者可否消费 0无产品，不可消费 1有产品，可消费
    public static int flag = 0;
    //锁对象
    public static Object lock = new Object();
}

2) 消费者

消费者 代码：

/**
 * @author .29.
 * @create 2023-10-18 21:18
 */
//继承Thread
public class Consumer extends Thread{
    //重写run方法
    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块
            synchronized(Product.lock){
                //3.判断货架是否上架了商品
                if(Product.flag == 0){
                    //没有商品线程进入等待
                    try {
                        Product.lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    //可以消费，消费者进行消费，总数-1
                    Product.count--;
                    System.out.println("消费者消费商品，还可消费"+Product.count+"件商品");
                    //4. 通过锁，唤醒与锁绑定的所有线程
                    Product.lock.notifyAll();
                    //5. 修改货架状态
                    Product.flag = 0;
                }
            }
        }

    }
}

测试：

/**
 * @author .29.
 * @create 2023-10-18 21:39
 */
public class Test {
    public static void main(String[] args){
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

        producer.start();
        consumer.start();
    }
}

运行：

生产者生产商品
消费者消费商品，还可消费9件商品
生产者生产商品
消费者消费商品，还可消费8件商品
生产者生产商品
消费者消费商品，还可消费7件商品
生产者生产商品
消费者消费商品，还可消费6件商品
生产者生产商品
消费者消费商品，还可消费5件商品
生产者生产商品
消费者消费商品，还可消费4件商品
生产者生产商品
消费者消费商品，还可消费3件商品
生产者生产商品
消费者消费商品，还可消费2件商品
生产者生产商品
消费者消费商品，还可消费1件商品
生产者生产商品
消费者消费商品，还可消费0件商品

3) 等待唤醒 —— 阻塞队列方式

阻塞队列继承结构：

• Iterable 接口
• Collection 接口
• Queue 接口
• BlockingQueue 接口
  • ①ArrayBlockingQueue 实现类
  • • 底层是数组，有界
  • ②LinkedBlockingQueue实现类
  • • 底层是链表，可看作无界，上限是int类型最大值

生产者 代码：

/**
 * @author .29.
 * @create 2023-10-19 10:19
 */
public class Producer extends Thread{
    private ArrayBlockingQueue<String> blockingQueue;

    public Producer(ArrayBlockingQueue<String> bq){
        blockingQueue = bq;
    }

    @Override
    public void run() {
        while(true){//不断生产商品
            try {
                blockingQueue.put("商品");
                System.out.println("生产者生产了商品"); //输出语句不在线程同步范围内
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

消费者 代码：

/**
 * @author .29.
 * @create 2023-10-19 10:19
 */
public class Consumer extends Thread{
    private ArrayBlockingQueue<String> blockingQueue;

    public Consumer(ArrayBlockingQueue<String> bq){
        blockingQueue = bq;
    }

    @Override
    public void run() {
        while(true){//不断消费商品
            String take = null;
            try {
                //take()，获取阻塞队列元素，方法底层已经实现线程同步
                take = blockingQueue.take();
                System.out.println("消费者消费了 :" + take); //输出语句不在线程同步范围内
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

测试：

public class test {
    public static void main(String[] args){
        //实例化BlockingQueue对象，传入参数1，表示阻塞队列长度为1
        ArrayBlockingQueue<String> bq = new ArrayBlockingQueue<>(1);

        Consumer consumer = new Consumer(bq);
        Producer producer = new Producer(bq);

        consumer.start();
        producer.start();
    }
}

输出：

生产者生产了商品
生产者生产了商品
消费者消费了 :商品
消费者消费了 :商品
生产者生产了商品
生产者生产了商品
消费者消费了 :商品
消费者消费了 :商品
生产者生产了商品
生产者生产了商品
消费者消费了 :商品
消费者消费了 :商品
生产者生产了商品
生产者生产了商品
消费者消费了 :商品
消费者消费了 :商品

• 输出存在重复现象，是因为输出语句不在线程同步范围内导致的，实际上put和take是线程安全的。

6. 线程状态

• 1）新建（NEW），至今尚未启动的线程处于这种状态。
• • 创建线程对象后
• 2)就绪（RUNNABLE）,正在Java虚拟机中执行的线程处于这种状态。
• • 调用start()后
• 3)阻塞（BLOCKING）,受阻塞并等待某个监视器锁的线程处于这种状态。
• • 无法获得锁对象时
• 4)等待（WAITING）,无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
• • 调用wait()后
• 5)计时等待（TIMED WAITING）,等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
• • 调用sleep()后
• 6)死亡（TERMINATED）,已退出的线程处于这种状态。
• • 全部代码运行完毕后

7. 线程池

核心原理：

• ①创建一个空的线程池
• ②提交任务时，线程池创建新的线程对象，执行完毕，线程归还线程池，等待下次任务
• ③提交任务时若线程池没有空闲线程，也无法创建新的线程（线程池满了），任务就会排队等待。
• 不断提交的任务，存在以下临界点：
• • 1. 当核心线程满时，再提交任务就会排队。
    2. 当核心线程满，队伍也满时，会创建临时线程。
    3. 核心线程满，队伍满，临时线程也满时，会触发任务拒绝策略。
  • 任务拒绝策略：
  • • ThreadPoolExecutor.AbortPolicy：默认策略、丢弃任务并抛出RejectedExecutionException异常
    • ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常，（不推荐）
    • ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入等待队列。
    • ThreadPoolExecutor.CallerRunsPolicy：调用任务的run()方法绕过线程池直接执行。

实现线程池：

• Executors：线程池的工具类，通过调用方法返回不同类型的线程池对象。
• • public static ExecutorService newCachedThreadPool()：创建一个没有上限的线程池。
• • public static ExcutorService newFixedThreadPool(int nThreads) ： 创建一个有上限的线程池，参数表示线程池的上限。
  • • submit(Runnable/Callable<> in)方法：提交任务
    • shutdown()方法：销毁线程池

自定义线程池

• 参数① 核心线程数量（不能小于0）
• 参数② 最大线程数量（不能小于0，最大数量 >= 核心线程数）
• 参数③ 空闲线程最大存活时间（不能小于0）
• 参数④ 时间单位（用TimeUnit指定）
• 参数⑤ 任务队列（不能为null）
• 参数⑥ 创建线程工厂（不能为null）
• 参数⑦ 任务的拒绝策略（不能为null）
• 任务拒绝策略：
• • ThreadPoolExecutor.AbortPolicy：默认策略、丢弃任务并抛出RejectedExecutionException异常
  • ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常，（不推荐）
  • ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入等待队列。
  • ThreadPoolExecutor.CallerRunsPolicy：调用任务的run()方法绕过线程池直接执行。

/**
 * @author .29.
 * @create 2023-10-19 12:08
 */
public class ThreadPoolDemo {
    public static void main(String[] args){

        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,         //核心线程数
                6,                     //最大线程数，不能小于0，需要大于等于核心线程数
                60,                    //空闲线程最大存活时间
                TimeUnit.SECONDS,      //时间单位，用TimeUnit设置
                new ArrayBlockingQueue<>(3), //任务队列
                Executors.defaultThreadFactory(),     //创建线程工厂
                new ThreadPoolExecutor.AbortPolicy() //任务的拒绝策略（线程池内部类）
        );

        pool.submit(new myCall());//提交任务
        
        pool.shutdown();//销毁线程池

    }
}