【Day11-多线程】

线程安全问题

• 多线程给我们的程序带来了很大性能上的提升，但是也可能引发线程安全问题
• 线程安全问题指的是当多个线程同时操作同一个共享资源的时候，可能会出现的操作结果不符预期问题

        取钱的线程安全问题

• 小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元
• 如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

         1、线程安全问题出现的原因？

                存在多个线程在同时执行

                同时访问一个共享资源

                存在修改该共享资源

                多个线程同时修改同一个资源

         案例：

/*
线程安全:
    多个线程同时修改同一个资源

取钱案例
    小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元
    如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

实现步骤
    1. 创建1个账户类，在类中定义账户金额和取钱方法
    2. 创建1个取钱线程类，在类中调用取钱方法
    3. 在主线程中创建1个账户对象代表二人的共享账户
    4. 在主线程中创建2个取钱线程，分别代表小明和小红，并将共享账户对象传递给2个线程处理
    5. 启动2个线程
*/
public class Demo {
    public static void main(String[] args) {
        //创建共享账户
        Account account = new Account();
        //创建两个取钱线程
        Person xiaoming = new Person(account);
        xiaoming.setName("小明");
        Person xiaohong = new Person(account);
        xiaohong.setName("小红");

        //开始取钱
        xiaohong.start();
        xiaoming.start();

    }
}

class Account{
    //在类中定义账户金额和取钱方法
    private Integer money = 100000;

    public void drawMoney(Integer drawMoney) {
        //判断是否足够
        if (drawMoney > money) {
            throw new RuntimeException(Thread.currentThread().getName() + "余额不足");
        }

        //模拟吐钱
        System.out.println(Thread.currentThread().getName() + ",ATM吐出" + drawMoney);
        //修改余额
        money -= drawMoney;
        System.out.println("余额是" + this.money);
    }
}

class Person extends Thread {
    //不能创建Account
    private Account account;
    //构造器
    public Person(Account account) {
        this.account = account;
    }

    //调用取钱的方法


    @Override
    public void run() {
        account.drawMoney(100000);
    }
}

 线程同步方案

         线程同步

• 线程同步就是让多个线程实现先后依次访问共享资源，这样就解决了安全问题，它最常见的方案就是加锁
• 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

          方式一：同步代码块

同步代码块 

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

 

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

        同步锁的注意事项 

• 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug
• 对于实例方法建议使用this作为锁对象
• 对于静态方法建议使用字节码（类名.class）对象作为锁对象

//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}

/*
同步代码块
    把访问共享资源的核心代码给上锁，以此保证线程安全

格式
    synchronized(同步锁){
        访问共享资源的核心代码
    }

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

注意
    1、对于当前同时执行的线程来说，同步锁必须是同一把(同一个对象)，否则会出bug注意
    2、同步锁不建议随便使用一个唯一的对象，也能锁住，但可能影响无关线程, 建议使用共享资源作为锁对象
        对于实例方法建议使用this作为锁对象规范
        对于静态方法建议使用字码(类名.class) 对象作为锁对象
*/
public class Account {

    //账户余额
    private Integer balance = 100000;

    //取钱
    public void drawMoney(Integer money) {
        //0.获取线程名称
        String threadName = Thread.currentThread().getName();

        //1. 判断余额是否充足
        synchronized (this) {
            if (money > balance) {
                System.out.println(threadName + "取钱失败,余额不足");
                return;//方法结束
            }

            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");

            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        }
    }
}

/*
测试类
*/
public class Demo {
    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        Person person2 = new Person(account);
        person1.setName("小明");
        person2.setName("小红");
        //3. 启动2个线程
        person1.start();
        person2.start();
    }
}

        1、同步代码块是如何实现线程安全的？ 

                对出现问题的核心代码使用synchronized进行加锁

                每次只能一个线程占锁进入访问

        2、同步代码块的同步锁对象有什么要求？

                对于实例方法建议使用this作为锁对象。

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

          方式二：同步方法

 同步方法

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

 

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

同步方法底层原理 

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
• 如果方法是实例方法：同步方法默认用this作为的锁对象。
• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}

/*
测试类
*/
public class Demo {

    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        Person person2 = new Person(account);

        //3. 启动2个线程
        person1.start();
        person2.start();

    }
}

/*
同步方法
    把访问共享资源的核心方法给上锁，以此保证线程安全。

格式
    修饰符 synchronized 返回值类型 方法名称(形参列表) {
    	操作共享资源的代码
    }

原理
    每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
    同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
    如果方法是实例方法：同步方法默认用this作为的锁对象。
    如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
*/
public class Account {

    //账户余额
    private Integer balance = 100000;

    //取钱
    public void drawMoney(Integer money) {

        money(money);

    }

    public synchronized void money(Integer money){
        //0.获取线程名称
        String threadName = Thread.currentThread().getName();
        //1. 判断余额是否充足
        if (money > balance) {
            System.out.println(threadName + "取钱失败,余额不足");
            return;//方法结束
        }

        //2. 如果够,出钱
        System.out.println(Thread.currentThread().getName() + "取钱成功");

        //3. 更新余额
        balance -= money;
        System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
    }
}

        1、同步方法是如何保证线程安全的？

                对出现问题的核心方法使用synchronized

                修饰每次只能一个线程占锁进入访问

        2、同步方法的同步锁对象的原理？

                对于实例方法默认使用this作为锁对象

                对于静态方法默认使用类名.class对象作为锁对象

        3、是同步代码块好还是同步方法好一点？ 

                范围上：同步代码块锁的范围更小，同步方法锁的范围更大。

                可读性：同步方法更好。

           方式三：lock锁

 Lock锁

• Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。 
• Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。 

构造器	说明
public ReentrantLock​()	获得Lock锁的实现类对象

Lock的常用方法 

方法名称	说明
void lock()	获得锁
void unlock()	释放锁

/*
测试类
*/
public class Demo {

    public static void main(String[] args) {
        //1. 创建一个账户对象
        Account account = new Account();

        //2. 创建两个取钱的人,并把账户交给它
        Person person1 = new Person(account);
        Person person2 = new Person(account);

        //3. 启动2个线程
        person1.start();
        person2.start();

    }
}

//取钱人
public class Person extends Thread {

    //账户
    private Account account;
    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        //调用取钱的方法
        account.drawMoney(100000);
    }
}

/*
Lock锁概述
    Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大
    Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建锁对象

方法
    public ReentrantLock() 创建锁对象
    public void lock()    上锁
    public void unlock() 释放锁

Lock锁使用规范
    规范1、锁对象创建在成员位置，使用final修饰
    规范2、释放锁的代码写在finally块中
*/
public class Account {

    //账户余额
    private Integer balance = 100000;
    Lock lock = new ReentrantLock();


    //取钱
    public void drawMoney(Integer money) {

        //0.获取线程名称
        String threadName = Thread.currentThread().getName();
        lock.lock();
        try {
            //1. 判断余额是否充足
            if (money > balance) {
                System.out.println(threadName + "取钱失败,余额不足");
                return;//方法结束
            }

            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");

            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
}

三种线程同步方式的对比 

	同步代码块	同步方法	lock
语法	synchronized (this){ }	synchronized 方法(){ }	lock.lock(); lock.unlock();
加锁方式	自动加锁、释放锁	自动加锁、释放锁	手动加锁、释放锁
锁粒度	代码行	方法	代码行

  线程池

当前创建线程的问题

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

什么是线程池

• 线程池就是一个可以复用线程的技术
• 它就像一个大的池子一样，里面可以放置一些线程，当需要的时候，就从里面取出来用，用完了就还回去
• 如此一来，就不必频繁的创建和销毁线程了，大大的提高了线程的利用率，提供系统的性能

 创建线程池的问题

 ThreadPoolExecutor

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

/*
线程池
    一个可以复用线程的技术

执行流程(核心线程-->工作队列-->临时线程-->拒绝策略)
    判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务
    如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列
    如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务
    如果最大线程数已满，则执行拒绝策略

对象创建
    接口 ExecutorService
    实现类 ThreadPoolExecutor
        int corePoolSize : 指定线程池的核心线程的数量
        int maximumPoolSize：指定线程池的最大线程数量
        long keepAliveTime ：指定临时线程的存活时间
        TimeUnit unit：指定临时线程存活的时间单位
        BlockingQueue<Runnable> workQueue：指定线程池的任务队列
        ThreadFactory threadFactory：指定线程池的线程工厂
        RejectedExecutionHandler handler：指定线程池的任务拒绝策略
*/
public class Demo1 {
    public static void main(String[] args) {
        //线程池的创建
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,          //线程池的核心线程数量
                5,      //线程池的最大线程数量
                60,       //指定临时线程的存活时间
                TimeUnit.SECONDS,       //指定临时线程的存活的时间单位
                new ArrayBlockingQueue<>(5),    //指定线程池的任务队列
                Executors.defaultThreadFactory(),       //指定线程池的线程工厂
                new ThreadPoolExecutor.AbortPolicy()    //指定线程池的拒绝策略
        );
        System.out.println(poolExecutor);
    }
}

 常用的参数

        1、谁代表线程池？

                ExecutorService接口---ThreadPoolExecutor实现类

        2、ThreadPoolExecutor的七个参数是什么意思

线程池处理Runnable任务 

ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future<T> submit(Callable<T> task)	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池！
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

/*
线程池执行Runnable任务
    void execute(Runnable command) 	执行Runnable任务
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo2 {
    public static void main(String[] args) {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(poolExecutor);
        poolExecutor.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(poolExecutor);
    }
}

        1、线程池如何处理Runnable任务？

                使用ExecutorService的方法：

                void  execute(Runnable target)

 线程池处理Callable任务 

ExecutorService的常用方法 

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future<T> submit(Callable<T> task)	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池！
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

/*
线程池执行Callable任务
    Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo3 {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

//        Future<Integer> future = poolExecutor.submit(new Callable<Integer>() {
//            @Override
//            public Integer call() throws Exception {
//                int count = 0;
//                for (int i = 0; i < 11; i++) {
//                    if (i % 2 == 0) {
//                        Thread.sleep(2000);
//                    }
//                    count += i;
//                }
//                return count;
//            }
//        });
        Integer count = future.get(2, TimeUnit.SECONDS);//java.util.concurrent.TimeoutException超过时间会报错
//        Integer count = future.get();
//        System.out.println("count" + count);
        Future<Integer> future = poolExecutor.submit(new MyTask(5));
        Integer sum = future.get();
        System.out.println(sum);

        Future<Integer> future1 = poolExecutor.submit(new MyTask(10));
        Integer sum1 = future1.get();
        System.out.println(sum1);

        List<Runnable> runnables = poolExecutor.shutdownNow();
        System.out.println(runnables);
    }
}

//需求: 编写一个任务类, 可以通过构造器接收n, 计算并返回1~n的和
class MyTask implements Callable<Integer> {
    private int n;

    public MyTask(int n) {
        this.n = n;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

        1、线程池如何处理Callable任务，并得到任务执行完后返回的结果？

                使用ExecutorService的方法：Future<T> submit(Callable<T> command)

 Executors工具类实现线程池

         但是我们一般不建议使用这些juc设定好的，因为并不完全贴合业务要求，还是建议自己设置线程池的参数

1、Executors工具类底层是基于什么方式实现的线程池对象？

线程池ExecutorService的实现类：ThreadPoolExecutor

2、Executors是否适合做大型互联网场景的线程池方案？

不合适。

建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。 

线程通信

 什么是线程通信？

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

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

• 生产者线程负责生产数据
• 消费者线程负责消费生产者生产的数据。
• 注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产！

/*
案例说明
    1) 3个厨师可以认为是生产者，负责生产包子，每次只能生产1个（生产者线程）
    2) 2个客人可以认为是消费者，负责消费包子，每次只能消费1个（消费者线程）
    3) 中间有张桌子用于存储包子，但是只能存储1个包子（桌子和包子是共享数据）

核心思路
	生产者线程放包子：
		 1)先判断桌子上是否有包子
		 2)没有包子时，开始做包子, 做完之后把别人唤醒，然后让自己等待
		 3)有包子时，不做包子了，直接唤醒别人，然后让自己等待
	消费者线程吃包子：
		 1)先判断是否有包子
		 2)有包子时，开始吃包子，吃完之后把别人唤醒，然后让自己等待
		 3)没有包子时，不吃包子了，直接唤醒别人，然后让自己等待

使用方法(使用当前同步锁对象进行调用)
    void wait()让当前线程等待并释放所占锁
    void notify()随机唤醒正在等待的某个线程
    void notifyAll()唤醒正在等待的所有线程
*/
//测试类
public class Demo {
    public static void main(String[] args) {
        //1. 将共享数据对象创建出来
        Desk desk = new Desk();

        //2. 创建3个生产者(厨师)线程
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                while (true) {
                    desk.set();
                }
            }, "厨师" + i).start();
        }

        //3. 创建2个消费者(顾客)线程
        for (int i = 1; i <= 2; i++) {
            new Thread(() -> {
                while (true) {
                    desk.get();
                }
            }, "顾客" + i).start();
        }
    }
}

class Desk {
    //维护一个集合,来放包子
    private List<String> list = new ArrayList<>();

    //放包子
    public synchronized void set() {
        try {
            //0. 获取线程的名字
            String name = Thread.currentThread().getName();

            //1. 先判断是否有包子
            if (list.size() == 0) {//没有包子
                System.out.println(name + "开始做包子");
                Thread.sleep(2000);
                list.add(name + "做的包子");

                //叫醒别人,自己休息=======>包子好了啊,我休息会
                this.notifyAll();
                this.wait();
            } else {//有包子
                //叫醒别人,自己休息=======>包子还有啊,我休息会
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //取包子
    public synchronized void get() {
        try {
            //0. 获取线程的名字
            String name = Thread.currentThread().getName();

            //1. 先判断是否有包子
            if (list.size() != 0) {//有包子
                System.out.println(name + "吃了" + list.remove(0));
                Thread.sleep(2000);

                //叫醒别人,自己休息=======>包子吃完啊,我休息会
                this.notifyAll();
                this.wait();
            } else {//没有包子
                //叫醒别人,自己休息=======>包子没了啊,我休息会
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

进程与线程

• 进程：正在运行的程序（软件）就是一个独立的进程
• 线程：线程是属于进程的，一个进程中可以同时运行很多个线程
• 关系：进程=火车     线程=车厢

 并发与并行

 多线程是并发和并行同时进行的

线程的生命周期和状态