Java进阶13讲__第12讲

Ø线程安全问题

Ø线程同步方案

Ø线程池

Ø线程通信

Ø理论补充

1. 线程安全问题

1.1 举例说明

1.2 代码实现

java">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;}@Overridepublic 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 方式一：同步代码块

java">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 方式二：同步方法

java">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锁

java">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任务

java">package com.itheima.e_线程池;import java.util.concurrent.*;/*
线程池一个可以复用线程的技术
执行流程(核心线程-->工作队列-->临时线程-->拒绝策略)判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务如果最大线程数已满，则执行拒绝策略
对象创建接口 ExecutorService实现类 ThreadPoolExecutorint 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任务

java">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));}
}

案例

java">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*/@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return sum;}
}