20天深度复习JavaSE的详细笔记(十七)——多线程

电玩女神 2023-10-02 21:07 2阅读 0赞

#### 文章目录 ####

*  Demo17-多线程
 *   *  1.线程概述
     *  2.多线程的创建
     *   *  2.1方式一:继承Thread类
         *  2.2方式二:实现Runnable接口
         *   *  2.2.1方案一:
             *  2.2.2方案二:实现Runnable接口(匿名内部类形式)
         *  2.3方式三:JDK5新增:实现Callable接口
     *  3.Thread的常用方法
     *  4.线程安全
     *  5.线程同步
     *   *  5.1同步代码块
         *  5.2同步方法
         *  5.3Lock锁
         *  5.4线程通信
     *  6.线程池
     *   *  6.1线程池概述
         *  6.2线程池实现的API,参数说明
         *  6.3线程池处理Runnable任务
         *  6.4线程池处理Callable任务
         *  6.5Executors工具类实现线程池
     *  7.定时器
     *   *  7.1Timer定时器
         *  7.2ScheduledExecutorService定时器
     *  8.并发与并行
     *  9.线程的生命周期

## Demo17-多线程 ##

### 1.线程概述 ###

什么是单线程:

*  线程是一个程序内部的一条执行路径
 *  我们之前启动程序执行后,main方法的执行其实就是一条单独的执行路径
 *  程序中如果只有一条执行路径,那么这个程序就是单线程的程序

什么是多线程:

*  多线程是指从软硬件上实现多条执行流程的技术

### 2.多线程的创建 ###

#### 2.1方式一:继承Thread类 ####

*  定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法
 *  创建MyThread类的对象
 *  调用线程对象的start()方法启动线程(启动后还是执行的run()方法)

public class ThreadDemo1 {
        
        public static void main(String[] args) {
        
            Thread t = new MyThread();
            t.start();//此后两个线程同时跑,也就是抢着执行输出语句
    
            for (int i = 0; i < 500; i++) {
        
                System.out.println("主线程执行输出：" + i);
            }
    
        }
    }
    
    class MyThread extends Thread{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 500; i++) {
        
                System.out.println("子线程执行输出：" + i);
            }
        }
    }

1.为什么不直接调用run()方法,而是调用start启动线程:

*  直接调用run方法会当成普通方法执行,一定会先执行完run方法再接着执行main中的代码,此时相当于还是单线程执行
 *  只有调用start方法才是启动一个新的线程执行

2.不要把主线程的业务逻辑放在子线程启动之前,否则一直是主线程先跑完的,相当于是一个单线程的效果

3.优缺点:

*  优点:编码简单
 *  缺点:线程只能继承Thread,无法继承其他类,不利于扩展

#### 2.2方式二:实现Runnable接口 ####

##### 2.2.1方案一: #####

*  定义一个**线程任务类**(并不是线程对象类,只是指定了执行什么任务)MyRunnable实现Runnable接口,重写run()方法
 *  创建MyRunnable**线程任务对象**(并不是线程对象)
 *  把MyRunnable任务对象交给Thread处理得到一个**线程对象**
 *  调用线程对象的start()方法启动线程

Thread的构造器:

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public Thread(String name)</td> 
   <td>可以为当前线程指定名称</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target)</td> 
   <td>封装Runnable对象成为线程对象</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target, String name)</td> 
   <td>封装Runnable对象成为线程对象,并指定线程名称</td> 
  </tr> 
 </tbody> 
</table>

public class ThreadDemo2 {
        
        public static void main(String[] args) {
        
            // 3、创建一个任务对象
            Runnable target = new MyRunnable();
            // 4、把线程任务对象交给Thread处理
            Thread t = new Thread(target);
            // Thread t = new Thread(target, "1号");
            // 5、启动线程
            t.start();
    
            for (int i = 0; i < 10; i++) {
        
                System.out.println("主线程执行输出：" + i);
            }
        }
    }
    
    //1、定义一个线程任务类 实现Runnable接口
    class MyRunnable  implements Runnable {
        
        //2、重写run方法，定义线程的执行任务
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println("子线程执行输出：" + i);
            }
        }
    }

优缺点:

*  优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
 *  缺点:编程多一层对象包装,如果线程有执行结果是不可以直接返回的(run方法无返回值)

##### 2.2.2方案二:实现Runnable接口(匿名内部类形式) #####

*  创建Runnable的匿名内部类对象
 *  交给Thread处理
 *  调用线程对象的start()启动线程

public class ThreadDemo2Other {
        
        public static void main(String[] args) {
        
            Runnable target = new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("子线程1执行输出：" + i);
                    }
                }
            };
            Thread t = new Thread(target);
            t.start();
    
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("子线程2执行输出：" + i);
                    }
                }
            }).start();
    
            new Thread(() -> {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("子线程3执行输出：" + i);
                }
            }).start();
    
            for (int i = 0; i < 10; i++) {
        
                System.out.println("主线程执行输出：" + i);
            }
        }
    }

#### 2.3方式三:JDK5新增:实现Callable接口 ####

前两种线程创建方式都存在一个问题:

*  他们重写的run方法均不能直接返回结果
    
     *  不适合需要返回线程执行结果的业务场景

JDK 5.0提供了Callable接口和FutureTask类来实现,这种方式的优点是可以得到线程执行的结果

FutureTask类的API

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public FutureTask&lt;&gt;(Callable call)</td> 
   <td>把Callable<strong>任务对象</strong>封装成FutureTask<strong>线程任务对象</strong></td> 
  </tr> 
  <tr> 
   <td>public V get() throws Exception</td> 
   <td>获取线程执行call方法返回的结果</td> 
  </tr> 
 </tbody> 
</table>

*  定义**任务类**(并不是线程类)实现Callable接口,重写call方法,封装要做的事情
    
     *  这是一个泛型接口,因为任务执行完后(任务是重写的call方法)要返回结果,结果类型未知,所以方法需是泛型方法,接口也随之需是泛型接口
 *  用FutureTask把Callable兑现封装成**线程任务对象**
    
     *  Callable接口的实现类的实例对象只是一个任务对象,而Thread构造器接收的参数是线程任务对象(Runnable接口的实现类)
     *  Callable接口没有继承Runnable接口,而FutureTask类经过多层实现最终实现了Runnable接口,所以**FutureTask类的实例对象可以作为参数传给Thread构造器**
 *  把线程任务对象交给Thread处理得到**线程对象**
 *  调用Thread的start方法启动线程,执行任务
 *  线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果(也就是call方法执行完的结果)
    
     *  Callable任务类对象交给FutureTask全权管理,FutureTask可以追踪Callable的call方法是否跑完,没跑完就不执行get,跑完了就执行get方法返回结果.为什么get一定会在线程执行完再调用呢,看get方法源码:
        
            public V get() throws InterruptedException, ExecutionException {
                    
                int s = state;
                if (s <= COMPLETING)
                    s = awaitDone(false, 0L);
                return report(s);
            }
        
        可以看出来,s是代表线程执行状态的,如果线程还没执行完,就会调用awaitDone方法,该方法内部有一个for(;;)循环,说明一直到线程执行完毕awaitDone才会执行完,然后才会执行report(s)方法返回执行结果
        
         *  从这个解释中我们也看出来了,下述案例的main方法就是一个线程,那么只要f2的get方法没有执行完毕,就一定不会执行f2.get()后的任何代码,所以案例输出结果的顺序一定是"第二个结果"在"第一个结果"之前,看下述案例的执行结果更能印证这个结论

![在这里插入图片描述][b3bae2b40c314312975aa2aea356a666.png_pic_center]

第一个子线程用时比第二个子线程少,但因为f2的get方法在f1的get方法之前,所以也只能是先输出第二个子线程的

public class ThreadDemo3 {
        
        public static void main(String[] args) {
        
            // 3、创建Callable任务对象
            Callable<String> call = new MyCallable(100000000);
            // 4、把Callable任务对象 交给 FutureTask 对象
            //  FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
            //  FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
            FutureTask<String> f1 = new FutureTask<>(call);
            // 5、交给线程处理
            Thread t1 = new Thread(f1);
            // 6、启动线程
            t1.start();
    
    
            Callable<String> call2 = new MyCallable(100000000);
            FutureTask<String> f2 = new FutureTask<>(call2);
            Thread t2 = new Thread(f2);
            t2.start();
    
            try {
        
                // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
                String rs2 = f2.get();
                System.out.println("第二个结果：" + rs2);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
            try {
        
                // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
                String rs1 = f1.get();
                System.out.println("第一个结果：" + rs1);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }
    
    // 1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
    class MyCallable implements Callable<String>{
        
        private int n;
        public MyCallable(int n) {
        
            this.n = n;
        }
    
        //2、重写call方法（任务方法）
        @Override
        public String call() throws Exception {
        
            long start = System.currentTimeMillis();
            int sum = 0;
            for (int i = 1; i <= n ; i++) {
        
                sum += i;
            }
            long end = System.currentTimeMillis();
            return "子线程执行的结果是：" + sum + "，执行时间是：" + (end - start);
        }
    }

优缺点:

*  优点:1.任务类(MyCallable)只是实现接口,可以继续继承类和实现接口2.可以在线程执行完毕后去获取线程执行的结果
 *  缺点:编码复杂一点

三种方式对比:

<table> 
 <thead> 
  <tr> 
   <th>方式</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>继承Thread类</td> 
   <td>编程比较简单,可以直接使用Thread类中的方法</td> 
   <td>扩展性较差,不能再继承其他的类,不能返回线程执行的结果</td> 
  </tr> 
  <tr> 
   <td>实现Runnable接口</td> 
   <td>扩展性强,实现该接口的同时还可以继承其他类</td> 
   <td>编程相对复杂,不能返回线程执行的结果</td> 
  </tr> 
  <tr> 
   <td>实现Callable接口</td> 
   <td>扩展性强,实现该接口的同时还可以继承其他类,可以得到线程执行的结果</td> 
   <td>编程相对复杂</td> 
  </tr> 
 </tbody> 
</table>

### 3.Thread的常用方法 ###

**Thread获取和设置线程的名称:**

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String getName()</td> 
   <td>获取当前线程的名称,默认线程名称是Thread-索引</td> 
  </tr> 
  <tr> 
   <td>void setName(String name)</td> 
   <td>将此线程的名称更改为指定的名称,也可以通过Thread构造器设置线程名称</td> 
  </tr> 
 </tbody> 
</table>

public class ThreadDemo01 {
        
        // main方法是由主线程负责调度的
        public static void main(String[] args) {
        
    
            //Thread.currentThread():哪个线程执行它,它就得到哪个线程对象,也就是获取当前线程对象
            // 主线程的名称就叫main
            Thread m = Thread.currentThread();
            System.out.println(m.getName());
    
            Thread t1 = new MyThread("1号");
            // t1.setName("1号");
            t1.start();
    
            Thread t2 = new MyThread("2号");
            // t2.setName("2号");
            t2.start();
    
            for (int i = 0; i < 5; i++) {
        
                System.out.println( m.getName() + "输出：" + i);
            }
        }
    }
    
    public class MyThread extends Thread{
        
        public MyThread() {
        
        }
        public MyThread(String name) {
        
            // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
            super(name);
        }
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println(Thread.currentThread().getName() + "输出：" + i);
            }
        }
    }

**Thread类的线程休眠方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sleep(long time)</td> 
   <td>让当前线程休眠指定的时间后再继续执行,单位为毫秒</td> 
  </tr> 
 </tbody> 
</table>

总结Thread常用方法,构造器

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String getName()</td> 
   <td>获取当前线程的名称,默认线程名称是Thread-索引</td> 
  </tr> 
  <tr> 
   <td>void setName(String name)</td> 
   <td>将此线程的名称更改为指定的名称,也可以通过Thread构造器设置线程名称</td> 
  </tr> 
  <tr> 
   <td>public static Thread currentTread()</td> 
   <td>返回对当前正在执行的线程对象的引用</td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long time)</td> 
   <td>让当前线程休眠指定的时间后再继续执行,单位为毫秒</td> 
  </tr> 
  <tr> 
   <td>public void run()</td> 
   <td>线程任务方法</td> 
  </tr> 
  <tr> 
   <td>public void start()</td> 
   <td>线程终结方法</td> 
  </tr> 
  <tr> 
   <td>public Thread(String name)</td> 
   <td>可以为当前线程指定名称</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target)</td> 
   <td>封装Runnable对象成为线程对象</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target, String name)</td> 
   <td>封装Runnable对象成为线程对象,并指定线程名称</td> 
  </tr> 
 </tbody> 
</table>

### 4.线程安全 ###

*  多个线程同时操作同一个共享资源的时候可能会出现业务安全问题,称为线程安全问题

模拟取钱案例:

public class ThreadDemo {
        
        public static void main(String[] args) {
        
            // 1、定义线程类，创建一个共享的账户对象
            Account acc = new Account(100000);
    
            // 2、创建2个线程对象，代表小明和小红同时进来了。
            new DrawThread(acc, "小明").start();
            new DrawThread(acc, "小红").start();
        }
    }
    
    public class DrawThread extends Thread {
        
        // 接收处理的账户对象
        private Account acc;
        public DrawThread(Account acc,String name){
        
            super(name);
            this.acc = acc;
        }
        @Override
        public void run() {
        
            // 小明 小红：取钱
            acc.drawMoney(100000);
        }
    }
    
    public class Account {
        
        private double money;
        public Account(double money) {
        
            this.money = money;
        }
        public void drawMoney(double money) {
        
            // 0、先获取是谁来取钱，线程的名字就是人名
            String name = Thread.currentThread().getName();
            // 1、判断账户是否够钱
            if(this.money >= money){
        
                // 2、取钱
                System.out.println(name + "来取钱成功，吐出：" + money);
                // 3、更新余额
                this.money -= money;
                System.out.println(name + "取钱后剩余：" + this.money);
            }else {
        
                // 4、余额不足
                System.out.println(name +"来取钱，余额不足！");
            }
        }
    }

### 5.线程同步 ###

*  取钱案例出现问题的原因:
    
     *  多个线程同时执行,发现账户都是够钱的
 *  如何才能保证线程安全呢
    
     *  让多个线程实现先后依次访问共享资源,这样就解决了安全问题
 *  也就是说线程同步是为了解决线程安全问题
 *  线程同步的核心思想
    
     *  加锁:把共享资源进行上锁,每次只能一个线程进入访问完毕以后解锁,然后其他线程才能进来

加锁的方式有好几种:

#### 5.1同步代码块 ####

*  作用:把出现线程安全问题的核心代码给上锁
 *  原理:每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
    
    > synchronize(同步锁对象) \{
    > 
    > 操作共享资源的代码(选中全部需要上锁的代码按ctrl+alt+t选择9.synchronize)
    > 
    > \}
    
    同步锁对象要求:
    
     *  理论上:**锁对象只要对于当前同时执行的线程来说是同一个对象即可**
     *  规范上:**建议使用共享资源作为锁对象**
        
         *  **对于实例方法建议使用this作为锁对象**
         *  **对于静态方法建议使用字节码(类名.class)对象作为锁对象**(我认为对于静态方法用常量作为锁对象和用字节码作用一模一样)

public class TestSafeDemo {
        
        public static void main(String[] args) {
        
            // 1、创建一个共享的账户对象。
            Account acc = new Account(100000);
    
            // 2、创建2个线程对象，操作同一个账户对象
            new DrawThread(acc, "小明").start();
            new DrawThread(acc,"小红").start();
    
        }
    }
    
    public class DrawThread extends Thread{
        
        private Account acc;
        public DrawThread(Account acc, String name){
        
            super(name);
            this.acc = acc;
        }
    
        @Override
        public void run() {
        
            acc.drawMoney(100000);
        }
    }
    
    public class Account {
        
        private double money;
        public Account(double money) {
        
            this.money = money;
        }
    
    //    // 静态方法使用字节码作为锁对象
    //    public static void run(){
        
    //        synchronized (Account.class){
        
    //        }
    //    }
    
        public void drawMoney(double money) {
        
            // 1、拿到是谁来取钱
            String name = Thread.currentThread().getName();
            // 同步代码块
            synchronized (this) {
        
                // 2、判断余额是否足够
                if(this.money >= money){
        
                    // 钱够了
                    System.out.println(name+"来取钱，吐出：" + money);
                    // 更新余额
                    this.money -= money;
                    System.out.println(name+"取钱后，余额剩余：" + this.money);
                }else{
        
                    // 3、余额不足
                    System.out.println(name+"来取钱，余额不足！");
                }
            }
        }
    }

注意:

*  第42行的this指的是调用drawMoney方法的实例对象,即前面定义的共享账户acc
 *  如果this改成Thread.currentThread()那肯定就不对了,因为得到的Thread对象对于执行的每个线程来讲都是不同的对象,而锁对象对于当前同时执行的线程来说必须是同一对象
 *  这个this我改成字符串如"China"也是可以的,因为这个"China"是在堆内存中存储的一个常量对象,那么对于当前同时执行的线程来说肯定是同一个对象
    
     *  但是做法不可行,因为这样做结果是所有取钱的人不论银行账户是否相同,都会被这一把锁锁起来,而我们想要的结果是不同账户取钱不会被锁起来,而同一账户取钱会被锁起来,所以还是用this,因为this代表的是一个银行账户

#### 5.2同步方法 ####

*  作用:把出现线程安全问题的核心方法给上锁
 *  原理:每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
    
    > 修饰符 synchronized 返回值类型 方法名称(形参列表) \{
    > 
    > 操作共享资源的代码
    > 
    > \}

具体实现方法就是把"4.线程安全"中的drawMoney方法加上synchronized,其他都不需要变

同步方法底层原理:

*  同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
 *  如果方法是实例方法:同步方法默认用this作为锁对象,但是代码要求必须高度面向对象
 *  如果方法是静态方法:同步方法默认用类名.class作为锁的对象

同步代码块和同步方法哪个更好?

*  同步代码块锁的范围更小,同步方法锁的范围更大,所以同步代码块要比同步方法性能好一点
 *  但因为同步方法实现方式简单,所以开发中还是用同步方法多

#### 5.3Lock锁 ####

*  为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock,更加灵活,方便
 *  Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
 *  Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public ReentrantLock()</td> 
   <td>获得Lock锁的实现类对象</td> 
  </tr> 
 </tbody> 
</table>

Lock的API

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void lock()</td> 
   <td>获得锁</td> 
  </tr> 
  <tr> 
   <td>void unlock()</td> 
   <td>释放锁</td> 
  </tr> 
 </tbody> 
</table>

public class TestSafeDemo {
        
        public static void main(String[] args) {
        
            Account acc = new Account(100000);
            
            new DrawThread(acc, "小明").start();
            new DrawThread(acc,"小红").start();
        }
    }
    
    public class DrawThread extends Thread{
        
        private Account acc;
        public DrawThread(Account acc, String name){
        
            super(name);
            this.acc = acc;
        }
    
        @Override
        public void run() {
        
            acc.drawMoney(100000);
        }
    }
    
    public class Account {
        
        private double money;
        
        // final修饰后：锁对象是唯一和不可替换的，非常专业
        private final Lock lock = new ReentrantLock();
        
        public Account(double money) {
        
            this.money = money;
        }
        public void drawMoney(double money) {
        
            String name = Thread.currentThread().getName();
            lock.lock(); // 上锁
            try {
        
                if(this.money >= money){
        
                    System.out.println(name+"来取钱，吐出：" + money);
                    this.money -= money;
                    System.out.println(name+"取钱后，余额剩余：" + this.money);
                }else{
        
                    System.out.println(name+"来取钱，余额不足！");
                }
            } finally {
        
                lock.unlock(); // 解锁
            }
        }
    }

*  第27行这里把锁对象用final修饰,防止别人替换锁,比如:lock=null
 *  第44行解锁放在finally里面是为了
    
     *  无论try里面的业务有无出错,最后都会执行解锁操作
        
         *  如果不用try…finally那么当上锁和加锁之间的业务出错时,这把锁就永远不会解锁,而变成死锁

#### 5.4线程通信 ####

理解思想就可以了,代码可以先不用理解

什么是线程通信,如何实现:

*  所谓线程通信就是线程间相互发送数据,线程通信通常通过共享一个数据的方式实现
 *  线程间会根据共享数据的情况决定自己该怎么做,以及通知其他线程怎么做

线程通信常见模型:

*  生产者与消费者模型:生产者线程负责生产数据,消费者线程负责消费数据
 *  要求:生产者线程生产完数据后,唤醒消费者,然后等待自己;消费者消费完该数据后,唤醒生产者,然后等待自己
    
     *  为什么要让自己等待呢?
        
         *  自己无事可做了,让自己等待可以让出CPU给别的线程用,提高性能

线程通信案例模拟:

*  假如有这样一个场景,小明和小红有三个爸爸,爸爸们负责存钱,小明和小红负责取钱,必须一存,一取(也就是只有余额为0是才可以存100,存后余额就满了,只有余额不为0时才可以取100,取后余额就为0了)
    
     *  线程通信的前提:线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信,且要保证线程安全

Object类的等待和唤醒方法:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void wait()</td> 
   <td>让当前线程等待并释放所占锁,直到另一个线程调用notify()或notifyAll()方法</td> 
  </tr> 
  <tr> 
   <td>void notify()</td> 
   <td>唤醒正在等待的单个线程</td> 
  </tr> 
  <tr> 
   <td>void notifyAll()</td> 
   <td>唤醒正在等待的所有线程</td> 
  </tr> 
 </tbody> 
</table>

**上述方法应该使用当前同步锁对象进行调用**(因为只有锁对象知道有多少抢我这把锁的线程需要我唤醒;只有锁对象知道谁在用我,我现在应该让谁等待)

//1.测试类
    public class ThreadDemo {
        
        public static void main(String[] args) {
        
            //1.创建账户对象,代表5个人共同的操作账户
            Account acc = new Account(0);
    
            //2.创建2个线程代表小明,小红
            new DrawThread(acc, "小明").start();
            new DrawThread(acc, "小红").start();
    
            //3.创建3个线程代表:亲爹,干爹,岳父
            new DepositThread(acc, "亲爹").start();
            new DepositThread(acc, "干爹").start();
            new DepositThread(acc, "岳父").start();
        }
    }
    
    //2.取钱的线程
    public class DrawThread extends Thread{
        
        private Account acc;
        public DrawThread(Account acc, String name) {
        
            super(name);
            this.acc = acc;
        }
        @Override
        public void run() {
        
            //小明 小红取钱
            while(true) {
        
                acc.drawMoney(100);
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }
    
    //3.存钱的线程
    public class DepositThread extends Thread{
        
        private Account acc;
        public DepositThread(Account acc, String name) {
        
            super(name);
            this.acc = acc;
        }
        @Override
        public void run() {
        
            //亲爹 干爹 岳父存钱
            while(true) {
        
                acc.deposit(100);
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }
    
    //4.账户实体类
    public class Account {
        
        private double money;
        public Account(double money) {
        
            this.money = money;
        }
    
        public synchronized void drawMoney(double money) {
        
            try {
        
                String name = Thread.currentThread().getName();
                if(this.money >= money){
        
                    //钱够,可取
                    this.money-=money;
                    System.out.println(name + "取钱" + money + "成功!取钱后余额是" + this.money);
    
                    //取完之后账户就没钱了,唤醒别人,等待自己
                    this.notifyAll();
                    this.wait();
                }else{
        
                    //钱不够,不可取,唤醒别人,等待自己
                    this.notifyAll();
                    this.wait();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
        public synchronized void deposit(double money) {
        
            try {
        
                String name = Thread.currentThread().getName();
                if(this.money == 0){
        
                    //余额为0,可存
                    this.money+=money;
                    System.out.println(name + "存钱" + money + "成功!存钱后余额是" + this.money);
    
                    //存钱后账户余额就满了,唤醒别人,等待自己
                    this.notifyAll();
                    this.wait();
                }else{
        
                    //账户余额已满,不可存,唤醒别人,等待自己
                    this.notifyAll();
                    this.wait();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

### 6.线程池 ###

#### 6.1线程池概述 ####

*  线程池就是一个可以复用线程的技术
 *  不使用线程池的问题
    
     *  如果用户没发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的(其一,它是一个对象它要占内存,其二,它还要竞争CPU来执行自己),这样会严重影响系统的性能

#### 6.2线程池实现的API,参数说明 ####

谁代表线程池:

*  JDK5.0起提供了代表线程池的接口:ExecutorService

如何得到线程池对象:

*  方式一:使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池对象
 *  方式二:使用Executors(线程池工具类)调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器的参数说明:

> public ThreadPoolExecutor(int corePoolSize,
> 
> int maximumPoolSize,
> 
> long keepAliveTime,
> 
> TimeUnit unit,
> 
> BlockingQueue workQueue,
> 
> ThreadFactory threadFactory,
> 
> RejectedExecutionHandler handler)
> 
> 参数一：指定线程池的线程数量（核心线程,长久不死亡的线程）： corePoolSize-------->不能小于0
> 
> 参数二：指定线程池可支持的最大线程数： maximumPoolSize-------->最大数量>=核心线程数量
> 
> 参数三：指定临时线程的最大存活时间(指的是临时线程没有任务处理时空闲的时间)： keepAliveTime-------->不能小于0
> 
> 参数四：指定存活时间的单位(秒、分、时、天)： unit-------->时间单位
> 
> 参数五：指定任务队列： workQueue-------->不能为null
> 
> 参数六：指定用哪个线程工厂创建线程(其实就是以前学的根据任务对象(Callable)或线程任务对象(Runnable)创建一个线程对象,这里进行了包装,不再需要我们手工编写对 new Thread的调用了,这个参数我们默认就用Executors.defaultThreadFactory())： threadFactory-------->不能为null
> 
> 参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler -------->不能为null

线程池常见面试题:

什么时候会将任务放到任务队列:

*  正在运行的线程数量大于或等于corePoolSize,且任务队列还没有满,那么就会将这个**任务**放入任务队列\*\*(注意任务队列中的只是任务而不是线程)\*\*

临时线程什么时候创建:

*  新任务提交时发现**核心线程都在忙,任务队列也满了,并且还可以创建临时线程**,此时才会创建**一个**临时线程,**并运行该任务**

什么时候会开始拒绝任务:

*  **核心线程和临时线程都在忙,任务队列也满了**,新的任务过来的时候才会开始任务拒绝

#### 6.3线程池处理Runnable任务 ####

ExecutorService的常用方法:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void execute(Runnable command)</td> 
   <td>执行任务/命令,没有返回值,一般用来执行Runnable任务</td> 
  </tr> 
  <tr> 
   <td>Future submit(Callable task)</td> 
   <td>执行任务,<strong>返回未来任务对象</strong>获取线程结果,一般拿来执行Callable任务</td> 
  </tr> 
  <tr> 
   <td>void shutdown()</td> 
   <td>等任务执行完毕后关闭线程池</td> 
  </tr> 
  <tr> 
   <td>List shutdownNow()</td> 
   <td>立刻关闭,停止正在执行的任务,并返回队列中未执行的任务</td> 
  </tr> 
 </tbody> 
</table>

新任务拒绝策略:

<table> 
 <thead> 
  <tr> 
   <th>策略</th> 
   <th>详解</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ThreadPoolExecutor.AbortPolicy</td> 
   <td>丢弃任务并抛出RejectedExecutionException异常,<strong>这是我们默认使用的策略</strong></td> 
  </tr> 
  <tr> 
   <td>ThreadPoolExecutor.DiscardPolicy</td> 
   <td>丢弃任务,但是不抛出异常(不推荐)</td> 
  </tr> 
  <tr> 
   <td>ThreadPoolExecutor.DiscardOldestPolicy</td> 
   <td>抛弃队列中等待最久的任务,然后把当前任务加入到队列中</td> 
  </tr> 
  <tr> 
   <td>ThreadPoolExecutor.CallerRunsPolicy</td> 
   <td>由主线程负责调用任何的run()方法从而绕过线程池直接执行,也就是由主线程处理该任务</td> 
  </tr> 
 </tbody> 
</table>

public class ThreadPoolDemo1 {
        
        public static void main(String[] args) {
        
            // 1、创建线程池对象
            /**
             public ThreadPoolExecutor(int corePoolSize,
                                     int maximumPoolSize,
                                     long keepAliveTime,
                                     TimeUnit unit,
                                     BlockingQueue<Runnable> workQueue,
                                     ThreadFactory threadFactory,
                                     RejectedExecutionHandler handler)
             */
            ExecutorService pool = new ThreadPoolExecutor(3, 5 , 6,
                                            TimeUnit.SECONDS, 
                                            new ArrayBlockingQueue<>(5) , 
                                            Executors.defaultThreadFactory(),
                                           new ThreadPoolExecutor.AbortPolicy() );
    
            // 2、把线程任务对象交给任务线程池处理
            Runnable target = new MyRunnable();
            pool.execute(target);
            pool.execute(target);
            pool.execute(target);
    
            pool.execute(target);
            pool.execute(target);
            pool.execute(target);
            pool.execute(target);
            pool.execute(target);
    
            // 创建临时线程
            pool.execute(target);
            pool.execute(target);
    
            try {
        
                //核心线程和临时线程都在忙,任务队列也已满了,拒绝策略被触发
                pool.execute(target);
            } catch (Exception e) {
        
                System.out.println("核心线程和临时线程都在忙,任务队列也已满了,不能再来了!");
            }
    
            // 关闭线程池（开发中一般不会使用）。
    //         pool.shutdownNow(); // 立即关闭，即使任务没有完成，会丢失任务的,不建议使用！
            pool.shutdown(); // 会等待全部任务(包括任务队列中的)执行完毕之后再关闭（建议使用的）
        }
    }
    
    public class MyRunnable implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==> "  + i);
            }
            try {
        
                System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~");
                Thread.sleep(100000);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

注意:

*  第44行如果不把第11个pool.execute(target);注释掉那么抛出异常后就不会再执行pool.shutdown();
    
     *  或者把第11个pool.execute(target);进行try…catch异常捕获
     *  拓宽一下知识:第11个pool.execute(target);不注释也不进行try…catch,运行程序会发现主线程报RejectedExecutionException异常,但是**其他线程仍会正常执行**,而不是整个程序都挂掉,我们可以这样理解:主线程执行时报错,但是这并不影响其他线程的正常执行,他们之间是独立的(但是我有个疑惑,为什么主线报异常后,即使我其他线程都已经执行完毕了还不执行shutdown关闭线程池?暂未解,我好像知道了,因为主线程挂了,不会再执行后面的shutdown代码了)
 *  第55行将线程休眠后,并不是说6秒后(针对这个案例,这个案例设置的临时线程存活时间是6秒)就会将临时线程丢弃,因为休眠并不是在空闲,此时还在处理这个任务

疑惑点:第15行为什么可以省略new ArrayBlockingQueue中的Runnable?

#### 6.4线程池处理Callable任务 ####

public class ThreadPoolDemo2 {
        
        public static void main(String[] args) throws Exception {
        
            // 1、创建线程池对象
            ExecutorService pool = new ThreadPoolExecutor(3, 5 , 6,
                                        TimeUnit.SECONDS,
                                        new ArrayBlockingQueue<>(5),
                                        Executors.defaultThreadFactory(),
                                        new ThreadPoolExecutor.AbortPolicy() );
    
            // 2、把任务对象(不是线程任务对象,因为Callable接口并没有继承Runnable接口)给任务线程池处理。
            Future<String> f1 = pool.submit(new MyCallable(100));
            Future<String> f2 = pool.submit(new MyCallable(200));
            Future<String> f3 = pool.submit(new MyCallable(300));
            Future<String> f4 = pool.submit(new MyCallable(400));
            Future<String> f5 = pool.submit(new MyCallable(500));
    
            System.out.println(f1.get());
            System.out.println(f2.get());
            System.out.println(f3.get());
            System.out.println(f4.get());
            System.out.println(f5.get());
        }
    }
    
    public class MyCallable implements Callable<String>{
        
        private int n;
        public MyCallable(int n) {
        
            this.n = n;
        }
        @Override
        public String call() throws Exception {
        
            int sum = 0;
            for (int i = 1; i <= n ; i++) {
        
                sum += i;
            }
            return Thread.currentThread().getName()
                    + "执行 1-" + n+ "的和，结果是：" + sum;
        }
    }

*  第11行的Future是我们在"2.3方式三:JDK5新增:实现Callable接口"学习的FutureTask接口的祖宗接口

#### 6.5Executors工具类实现线程池 ####

Executors得到线程池对象的常用方法:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
   <th>存在问题</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static ExecutorService newCachedThreadPool()</td> 
   <td>线程数量随着任务增加而增加,如果线程任务执行完毕且空闲了一段时间则会被回收掉</td> 
   <td>创建的线程数量最大上限是Integer.MAX_VALUE,线程数可能会随着任务1:1增长,可能出现OOM错误(java.lang.OutOfMemoryError)</td> 
  </tr> 
  <tr> 
   <td><strong>public static ExecutorService newFixedThreadPool(int nThreads)</strong></td> 
   <td><strong>创建固定线程数量的线程池,如果某个线程因执行代码异常而结束,那么线程池会补充一个新线程替代它</strong></td> 
   <td>允许请求的任务队列长度是Integer.MAX_VALUE,可能出现OOM错误(java.lang.OutOfMemoryError)</td> 
  </tr> 
  <tr> 
   <td>public static ExecutorService newSingleThreadExecutor()</td> 
   <td>创建只有一个线程的线程池对象,如果该线程出现异常而结束,那么线程池会补充一个新线程</td> 
   <td>允许请求的任务队列长度是Integer.MAX_VALUE,可能出现OOM错误(java.lang.OutOfMemoryError)</td> 
  </tr> 
  <tr> 
   <td>public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)</td> 
   <td>创建一个线程池,可以实现在给定的延迟后运行任务,或者定期执行任务</td> 
   <td>创建的线程数量最大上限是Integer.MAX_VALUE,线程数可能会随着任务1:1增长,可能出现OOM错误(java.lang.OutOfMemoryError)</td> 
  </tr> 
 </tbody> 
</table>

*  由以上存在问题可以知道大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里巴巴java开发手册明确规定线程池不允许使用Executors去创建而是使用ThreadPoolExecutor来指定线程池参数以规避资源耗尽的风险)
 *  **Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的**看public static ExecutorService newFixedThreadPool(int nThreads)的源码:

public static ExecutorService newFixedThreadPool(int nThreads) {
        
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

可以发现也是套娃!!

public class ThreadPoolDemo3 {
        
        public static void main(String[] args) throws Exception {
        
            // 1、创建固定线程数据的线程池
            ExecutorService pool = Executors.newFixedThreadPool(3);
    
            pool.execute(new MyRunnable());
            pool.execute(new MyRunnable());
            pool.execute(new MyRunnable());
            pool.execute(new MyRunnable());
        }
    }
    
    public class MyRunnable implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==> "  + i);
            }
            try {
        
                System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~(线程此时并不是在空闲状态,因为线程此时还是在处理任务,只是此时被休眠了)");
                Thread.sleep(1000);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

### 7.定时器 ###

定时器:

*  定时器是一种控制任务延时使用,或者周期调用的技术
 *  作用:闹钟,定时邮件发送

定时器的实现方式:

*  方式一:Timer
 *  方式二:ScheduledExecutorService

#### 7.1Timer定时器 ####

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public Timer()</td> 
   <td>创建一个Timer定时器对象</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void schedule(TimerTask task, long dely, long period)</td> 
   <td>开启一个**定时器,**按照计划处理TimerTask任务</td> 
  </tr> 
 </tbody> 
</table>

1.Timer定时器的特点和存在的问题:

*  Timer是单线程,处理多个任务按照顺序执行,存在延时与设置定时器的时间有出入
 *  可能因为其中的某个任务的异常是Timer线程死掉,从而影响后续任务执行

2.一步步点源码可以看到TimerTask 抽象类继承Runnable,所以说TimerTask 的抽先类实例对象就是一个**线程任务对象**,老师说了**Timer实例对象本身就是一个单线程对象(顺便提一嘴,Thread实例对象也是一个单线程对象)**,所以Timer实例对象调用schedule方法处理线程任务对象TimerTask 的任务(和"2.2.1方案一"很像,区别是那一个还要将线程任务对象封装成线程对象再启动线程处理任务,而这一个直接将线程任务对象传给schedule方法就可以处理任务了,并且还可以**定时,周期的处理任务**)

public class TimerDemo1 {
        
        public static void main(String[] args) {
        
            // 1、创建Timer定时器
            Timer timer = new Timer();  // 定时器本身就是一个单线程。
            // 2、调用方法，处理定时任务
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行一次~~~");
                }
            }, 3000, 2000);
        }
    }

怎么理解上述说的"1.Timer定时器存在延时与设置定时器的时间有出入2.可能因为其中的某个任务的异常是Timer线程死掉,从而影响后续任务执行"?

*  第二个很好理解,因为Timer是单线程对象,这个线程中如果有业务逻辑出错并且没有捕获处理,就会最终抛出异常至虚拟机导致后面的业务逻辑就不会继续执行
 *  第一个用案例解释:

public class TimerDemo1 {
        
        public static void main(String[] args) {
        
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行AAA~~~" + new Date());
                    try {
        
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }, 0, 2000);
    
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+ new Date());
                }
            }, 0, 2000);
        }
    }

最终这AAA和CCC都会因为AAA每次休眠5秒而延时与设置定时器的时间有出入

#### 7.2ScheduledExecutorService定时器 ####

*  ScheduledExecutorService 是JDK5中引入了并发包,目的是为了弥补Timer的缺陷,ScheduledExecutorService 内部为线程池

<table> 
 <thead> 
  <tr> 
   <th>Executors的方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)</td> 
   <td>得到线程池对象</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>ScheduledExecutorService的方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public ScheduledFuture&lt;?&gt; scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)</td> 
   <td>周期调度方法</td> 
  </tr> 
 </tbody> 
</table>

ScheduledExecutorService的优点:

*  基于线程池,某个任务的执行情况不会影响其他定时任务的执行

public class TimerDemo2 {
        
        public static void main(String[] args) {
        
            // 1、创建ScheduledExecutorService线程池，做定时器
            ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
    
            // 2、开启定时任务
            pool.scheduleAtFixedRate(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行输出：AAA  ==》 " + new Date());
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }, 0, 2, TimeUnit.SECONDS);
    
    
            pool.scheduleAtFixedRate(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行输出：BBB  ==》 " + new Date());
                    System.out.println(10 / 0);
                }
            }, 0, 2, TimeUnit.SECONDS);
    
    
            pool.scheduleAtFixedRate(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + "执行输出：CCC  ==》 " + new Date());
                }
            }, 0, 2, TimeUnit.SECONDS);
        }
    }

第24行业务逻辑出错后其他线程正常运行我是知道的,可是控制台竟然打出没有这个错误线程的异常信息?我怀疑是内部进行优化了,比如底层捕获后处理?

### 8.并发与并行 ###

正在运行的程序(软件)就是一个独立的进程,线程是属于进程的,多个线程其实是并行与并发同时进行的

并发的理解:

*  CPU同时处理线程的数量有限
 *  CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发

并行的理解:

*  在同一时刻上,同时有多个线程在被CPU处理并执行(依赖于CPU的逻辑处理器)

### 9.线程的生命周期 ###

线程的状态:

*  也就是线程从生到死的过程,以及中间经历的各种状态及状态转换
 *  理解线程的状态有利于提升并发编程的理解能力

java线程的状态:

*  java共定义了6中状态,6中状态定义在Thread类的内部枚举类State中

<table> 
 <thead> 
  <tr> 
   <th>线程状态</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>NEW(新建)</td> 
   <td>线程刚被创建,但是并未启动</td> 
  </tr> 
  <tr> 
   <td>Runnable(可运行)</td> 
   <td>线程已经调用了start(),此时在等待CPU调度</td> 
  </tr> 
  <tr> 
   <td>Blocked(锁阻塞)</td> 
   <td>线程在执行的时候未竞争到锁对象,则该线程进入Blocked状态</td> 
  </tr> 
  <tr> 
   <td>Waiting(无线等待)</td> 
   <td>一个线程进入Waiting状态,另一个线程调用notify或notifyAll才能够唤醒</td> 
  </tr> 
  <tr> 
   <td>Timed Waiting(计时等待)</td> 
   <td>超时参数的常用方法有Thread.sleep，Object.wait</td> 
  </tr> 
  <tr> 
   <td>Teminated(被终止)</td> 
   <td>因为run方法正常退出而死亡,或者因为没有捕获异常终止了run方法而死亡</td> 
  </tr> 
 </tbody> 
</table>

![在这里插入图片描述][065732aef50d4927b21f80886772de7d.png_pic_center]

注意:**sleep的时候并没有释放锁,所以sleep时间到后直接就是可运行状态**

[b3bae2b40c314312975aa2aea356a666.png_pic_center]: https://img-blog.csdnimg.cn/b3bae2b40c314312975aa2aea356a666.png#pic_center
[065732aef50d4927b21f80886772de7d.png_pic_center]: https://img-blog.csdnimg.cn/065732aef50d4927b21f80886772de7d.png#pic_center