Java学习-20 多线程

什么是线程？

线程（Thread）是一个程序内部的一条执行流程

程序中如果只有一条执行流程，那这个程序就是单线程的程序

多线程是什么？

多线程是指从软硬件上实现的多条执行流程的技术（多线程由CPU负责调度执行）。

如何在程序中创建多条线程？

Java是通过java.lang.Thread类的对象来代表线程的。

多线程的创建方式一：集成Thread类

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

 方式一优缺点：

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展

多线程的注意事项

1. 启动线程必须是调用start()方法，不是调用run()方法
2. 不要把主线程任务放在启动子线程之前

多线程的创建方式二：实现Runable接口

1. 定义一个线程任务类MyRunable实现Runable接口，重写run()方法
2. 创建MyRunable任务对象
3. 把MyRunable任务对象交给Thread处理
4. 调用线程对象的start()方法启动线程

方式二的优缺点

优点：任务类只是实现接口，可以继续继承其他类，实现其他接口，扩展性强

缺点：需要多一个Runable对象

线程创建方式二的匿名内部类写法

1. 可以创建Runable的匿名内部类对象
2. 再交给Thread线程对象
3. 在调用线程对象的start()启动线程

public class ThreadTest2_2 {
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1输出====" + i);
                }
            }
        };
        new Thread(target).start();
        // 简化1
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2输出====" + i);
                }
            }
        }).start();
        // lambda简化
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程3输出====" + i);
            }
        }).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("Main线程在输入====" + i);
        }
    }
}

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

假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果

怎么解决这个问题？

JDK5.0提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）。

这种方式最大的优点：可以返回线程执行完毕的结果

多线程的第三种创建方式：利用Callable接口和FutureTask类实现

        1、创建任务对象

                -->定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。

                -->把callable类型的对象封装成FutureTask（线程任务对象）。

        2、把线程任务对象交给Thread对象

        3、调用Thread对象的start方法启动线程

        4、线程执行完毕后，通过FutureTask对象的get方法获取线程任务执行结果

线程创建方式三的优缺点：

优点：线程任务类只是实现接口，可以继承类和实现接口，扩展性强，可以在线执行完毕后去获取线程执行的结果

缺点：编码复杂一点

public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        Callable<String> call = new MyCallable(100);
        // 把Callable的对象封装成一个FutureTask对象（任务对象）
        //任务对象，实现了Runnable对象
        //可以在任务执行完毕后调用对象的get方法获取线程执行完毕的返回结果
        FutureTask<String> f1 = new FutureTask<>(call);
        // 任务对象封装给Thread对象
        new Thread(f1).start();
        // 获取线程执行完毕后的结果
        // 上面线程没有执行完毕 该处会等待
        String rs = f1.get();
        System.out.println(rs);

        // 穿插执行互不干扰
        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        new Thread(f2).start();
        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

Thread提供的方法

public class ThreadTest1 {
    public static void main(String[] args) {
        // getName()获取线程名字
        Thread t1 = new MyThread("1号线程");
        // 为线程设置名称 setName()
        // t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread("2号线程");
        // t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName());

        // 主线程名字
        Thread a = Thread.currentThread();
        a.setName("Main线程");
        System.out.println(a.getName());
        for (int i = 0; i < 3; i++) {
            System.out.println("main线程输出：" + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5; i++) {
            System.out.println(i);
            if(i==3){
                // 让当前线程休眠5秒 sleep(毫秒)
                Thread.sleep(2000);
            }
        }

        // 控制线程执行顺序 join()
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

什么是线程安全问题？

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

同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

synchronized(同步锁){

        访问共享资源的核心代码

}

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步锁的注意事项：

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

锁对象随便选择一个唯一的对象好不好呢？

不好，会影响其他无关线程的执行

锁对象的使用规范

建议使用共享资源作为锁对象，对于实例方法建立使用this作为锁对象

对于静态方法建议使用字节码（类名.class）对象作为锁对象

synchronized (this) {
            if(this.money>= money){
                System.out.println(name + "来取钱：" + money);
                this.money -= money;
                System.out.println(name + "取钱后，余额剩余：" + this.money);
            } else {
                System.out.println(name + "取钱失败，余额不足");
            }
        }

同步方法

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

修饰符 synchronized 返回值类型 方法名称(形参列表) {

                操作共享资源代码;

}

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步方法底层原理

同步方法其实底层也是隐式锁对象的，只是锁的范围是整个方法代码。

如果方法时实例方法：同步方法默认用this作为的锁对象。

如果方法时静态方法：同步方法默认用类名.class作为的锁对象

同步代码块锁的范围小，相对性能好些！

 public synchronized void drawMoney(double money) 

Lock锁

Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

private final Lock LK = new ReentrantLock();
    public void drawMoney(double money) {
        // 获取
        String name = Thread.currentThread().getName();
        LK.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 + "取钱失败，余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            LK.unlock();
        }
    }

什么是线程通信？

当多个线程共同操作共享的资源时，线程间通过某种方式相互告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）

生产者线程负责生产数据

消费者线程负责消费生产者生产的数据

注意：生产者生产完数据应该等待自己，通知消费者消费，消费者消费完数据也应该等待自己，通知生产者生产！

public class Desk {
    private List<String> list = new ArrayList<>();
// 厨师1、厨师2、厨师3都要调用 防止同步线程出错 加synchronized
    public synchronized void put()  {
        try {
            String name = Thread.currentThread().getName();
            if(list.size()==0){
                list.add(name + "做了一个肉包子！");
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);
                // 唤醒其他线程 自己等待
                this.notify();
                this.wait();
            } else {
                // 唤醒其他线程 自己等待
                this.notify();
                this.wait();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 吃货1 吃货2
    public synchronized void get(){
        String name = Thread.currentThread().getName();
        try {
            if(list.size()==1){
                list.remove(0);
                System.out.println(name + "吃了一个肉包子");
                Thread.sleep(1000);

                // 唤醒其他线程 自己等待
                this.notify();
                this.wait();
            }else {
                // 唤醒其他线程 自己等待
                this.notify();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Desk desk = new Desk();

        new Thread(()->{
            while (true) {
                desk.put();
            }
        }, "厨师1").start();
        new Thread(()->{
            while (true) {
                desk.put();
            }
        }, "厨师2").start();
        new Thread(()->{
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        new Thread(()->{
            while (true) {
                desk.get();
            }
        }, "吃货1").start();
        new Thread(()->{
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

线程池

是一个可以复用线程的技术

不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

谁代表线程池

JDK 5.0起提供了代表线程池的接口:Executorservice。

如何得到线程池对象?
方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线

方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象。

ThreadPoolExecutor构造器

• 参数一：corePoolSize:指定线程池的核心线程的数量。
• 参数二：maximumPoolSize:指定线程池的最大线程数量。
• 参数三：keepAliveTime:指定临时线程的存活时间。
• 参数四：unit:指定临时线程存活的时间单位(秒、分、时、天)
• 参数五：workQueue:指定线程池的任务队列。
• 参数六：threadFactory:指定线程池的线程工厂
• 参数七：handler:指定线程池的任务拒绝策略(线程都在忙，任务队列也满了的时候，新任务来了该怎么处理)

线程池的注意事项
1、临时线程什么时候创建?
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
2、什么时候会开始拒绝新任务?
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

新任务拒绝策略

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

Executors
是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

方法名称	说明
newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
newScheduledThreadPool(int corePoolsize)	创建一个线程池，可以实现在给定的延迟后运行任务或者定期执行任务。

注意:这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险

进程

• 正在运行的程序（软件）就是一个独立的进程
• 线程是属于进程的，一个进程中可以同时运行很多个线程
• 进程中的多个线程其实是并发和并行执行的

并发含义

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

在同一时刻上，同时有多个线程在被CPU调度执行 

线程的生命周期

• 也就是线程从生到死的过程中，经历的各种状态及状态转换。 
• 理解线程这些状态有利于提升并发编程的理解能力。

Java线程的6种状态

Thread.State()


 

线程的6种状态总结

线程状态	说明
NEW(新建)	线程刚被创建，但是并未启动。
Runnable(可运行)	线程已经调用了start()，等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态;。
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyA11方法才能够唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法(sleep,wait)有超时参数，调用他们将进入Timed Waiting状态
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。