Java进阶13讲__第12讲

Ø线程安全问题

Ø线程同步方案

Ø线程池

Ø线程通信

Ø理论补充

1. 线程安全问题

1.1 举例说明

1.2 代码实现

package com.itheima.a_线程安全;

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

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

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

//5. 启动2个线程
class Person extends Thread {
    private Account account;

    public Person(Account account) {
        this.account = account;
    }

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

//1. 创建1个账户类，在类中定义账户金额和取钱方法
class Account {
    private Integer Money = 100000;

    public void drawMoney(Integer drawMoney) {
        if (drawMoney <= Money) {
            System.out.println(Thread.currentThread().getName() + "取钱" + drawMoney + "元成功");
            Money -= drawMoney;
            System.out.println(Thread.currentThread().getName() + "余额已更新");
            System.out.println(Thread.currentThread().getName() + "余额为：" + Money);
        } else {
            throw new RuntimeException("账户余额不足");
        }
    }
}

2. 线程同步方案

2.1 认识线程同步

2.2 方式一：同步代码块

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

格式
    synchronized(同步锁){
        访问共享资源的核心代码
    }
原理
    每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
注意
    1、对于当前同时执行的线程来说，同步锁必须是同一把(同一个对象)，否则会出bug注意
    2、同步锁不建议随便使用一个唯一的对象，也能锁住，但可能影响无关线程, 建议使用共享资源作为锁对象
        对于实例方法建议使用this作为锁对象规范
        对于静态方法建议使用字码(类名.class) 对象作为锁对象
*/
public class Account {
    //账户余额
    private Integer balance = 100000;
    //取钱
    public void drawMoney(Integer money) {
        //0.获取线程名称
        //1. 判断余额是否充足
        synchronized (this) {
            if (money > balance) {
                System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
                return;//方法结束
            }
            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");
            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        }
    }
}

2.3 方式二：同步方法

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

格式
    修饰符 synchronized 返回值类型 方法名称(形参列表) {
    	操作共享资源的代码
    }
原理
    每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
    同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
    如果方法是实例方法：同步方法默认用this作为的锁对象。
    如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
*/
public class Account {
    //账户余额
    private Integer balance = 100000;
    //取钱
    public synchronized void drawMoney(Integer money) {
        //0.获取线程名称
        //1. 判断余额是否充足
        if (money > balance) {
            System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
            return;//方法结束
        }
        //2. 如果够,出钱
        System.out.println(Thread.currentThread().getName() + "取钱成功");
        //3. 更新余额
        balance -= money;
        System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
    }
}

2.4 方式三：Lock锁

package com.itheima.d_线程同步_lock锁;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
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;
    private final 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();
        }
    }
}

2.5 三种线程同步方法对比

3. 线程池

3.1 认识线程池

3.1.1 定义

3.1.2 线程池工作原理

3.1.3 线程池的执行流程

3.2 如何创建线程池？

3.3 线程池处理Runnable任务

package com.itheima.e_线程池;

import java.util.concurrent.*;

/*
线程池
    一个可以复用线程的技术
执行流程(核心线程-->工作队列-->临时线程-->拒绝策略)
    判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务
    如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列
    如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务
    如果最大线程数已满，则执行拒绝策略
对象创建
    接口 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) {
        ExecutorService es = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(es);
        //核心线程
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        //等待队列
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        //临时线程
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        System.out.println(es);
        //提交多次任务
//        for (int i = 0; i < 10; i++) {
//            es.execute(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread());
//                    System.out.println("执行任务");
//                }
//            });
//        }

    }
}

3.4 线程池处理Callable任务

package com.itheima.e_线程池;

import java.util.concurrent.*;

/*
线程池执行Runnable任务
    Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo3 {
    public static void main(String[] args) throws Exception {
        ExecutorService es = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(es);
        Future<Integer> future = es.submit(() -> {
            int count = 0;
            for (int i = 0; i < 11; i++) {
                if (i % 2 == 0) {
                    //遇到偶数休眠两秒
                    Thread.sleep(2000);
                }
                count += i;
            }
            return count;
        });
//        System.out.println("count:" + future.get());
        System.out.println("count:" + future.get(5, TimeUnit.SECONDS));
    }
}

案例

package com.itheima.e_线程池;

import java.util.concurrent.*;

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

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

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

    /**
     * 计算1-n的和
     *
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}