南京网络推广公司排行榜,seo全网推广营销软件,仿同程网 连锁酒店 网站模板,四川seo优化1. 线程池
1.1 线程状态介绍
当线程被创建并启动以后#xff0c;它既不是一启动就进入了执行状态#xff0c;也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么 Java 中的线程存在哪几种状态呢#xff1f;Java 中的线程
状态被定义在了 java.lang.Thread.…1. 线程池
1.1 线程状态介绍
当线程被创建并启动以后它既不是一启动就进入了执行状态也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么 Java 中的线程存在哪几种状态呢Java 中的线程
状态被定义在了 java.lang.Thread.State 枚举类中State 枚举类的源码如下
public class Thread {public enum State {/* 新建 */NEW ,/* 可运行状态 */RUNNABLE ,/* 阻塞状态 */BLOCKED ,/* 无限等待状态 */WAITING ,/* 计时等待 */TIMED_WAITING ,/* 终止 */TERMINATED;}// 获取当前线程的状态public State getState() {return jdk.internal.misc.VM.toThreadState(threadStatus);}}通过源码我们可以看到 Java 中的线程存在 6 种状态每种线程状态的含义如下
线程状态具体含义NEW一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建但是并未启动。还没调用 start 方法。MyThread t new MyThread() 只有线程象没有线程特征。RUNNABLE当我们调用线程对象的 start 方法那么此时线程对象进入了 RUNNABLE 状态。那么此时才是真正的在 JVM 进程中创建了一个线程线程一经启动并不是立即得到执行线程的运行与否要听令与 CPU 的调度那么我们把这个中间状态称之为可执行状态 (RUNNABLE) 也就是说它具备执行的资格但是并没有真正的执行起来而是在等待 CPU 的度。BLOCKED当一个线程试图获取一个对象锁而该对象锁被其他的线程持有则该线程进入 Blocked 状态当该线程持有锁时该线程将变成 Runnable 状态。WAITING一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种分别是调用 Object.wait()、join() 方法。处于等待状态的线程正在等待其他线程去执行一个特定的操作。例如因为 wait() 而等待的线程正在等待另一个线程去调用 notify() 或 notifyAll()一个因为 join() 而等待的线程正在等待另一个线程结束。TIMED_WAITING一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种分别是Thread.sleep(long)Object.wait(long)、join(long)。TERMINATED一个完全运行完成的线程的状态。也称之为终止状态、结束状态
各个状态的转换如下图所示 1.2 线程池 - 基本原理
概述:
提到池大家应该能想到的就是水池。水池就是一个容器在该容器中存储了很多的水。那么什么是线程池呢线程池也是可以看做成一个池子在该池子中存储很多个线程。
线程池存在的意义
系统创建一个线程的成本是比较高的因为它涉及到与操作系统交互当程序中需要创建大量生存期很短暂的线程时频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系
统资源的消耗这样就有点 舍本逐末 了。针对这一种情况为了提高性能我们就可以采用线程池。线程池在启动的时会创建大量空闲线程当我们向线程池提交任务的时线程池就
会启动一个线程来执行该任务。等待任务执行完毕以后线程并不会死亡而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
线程池的设计思路:
准备一个任务容器一次性启动多个 (2 个) 消费者线程刚开始任务容器是空的所以线程都在 wait直到一个外部线程向这个任务容器中扔了一个 任务 就会有一个消费者线程被唤醒这个消费者线程取出 任务 并且执行这个任务执行完毕后继续等待下一次任务的到来
1.3 线程池 -Executors 默认线程池
概述: JDK 对线程池也进行了相关的实现在真实企业开发中我们也很少去自定义线程池而是使用 JDK 中自带的线程池。
我们可以使用 Executors 中所提供的静态方法来创建线程池
static ExecutorService newCachedThreadPool() 创建一个默认的线程池
static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
代码实现:
package com.itheima.mythreadpool;//static ExecutorService newCachedThreadPool() 创建一个默认的线程池
//static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class MyThreadPoolDemo {public static void main(String[] args) throws InterruptedException {//1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.ExecutorService executorService Executors.newCachedThreadPool();//Executors --- 可以帮助我们创建线程池对象//ExecutorService --- 可以帮助我们控制线程池executorService.submit(()-{System.out.println(Thread.currentThread().getName() 在执行了);});//Thread.sleep(2000);executorService.submit(()-{System.out.println(Thread.currentThread().getName() 在执行了);});executorService.shutdown();}
}
1.4 线程池 -Executors 创建指定上限的线程池
使用 Executors 中所提供的静态方法来创建线程池
static ExecutorService newFixedThreadPool(int nThreads): 创建一个指定最多线程数量的线程池
代码实现:
package com.itheima.mythreadpool;//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最多线程数量的线程池import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;public class MyThreadPoolDemo2 {public static void main(String[] args) {//参数不是初始值而是最大值ExecutorService executorService Executors.newFixedThreadPool(10);ThreadPoolExecutor pool (ThreadPoolExecutor) executorService;System.out.println(pool.getPoolSize());//0executorService.submit(()-{System.out.println(Thread.currentThread().getName() 在执行了);});executorService.submit(()-{System.out.println(Thread.currentThread().getName() 在执行了);});System.out.println(pool.getPoolSize());//2
// executorService.shutdown();}
}
1.5 线程池 -ThreadPoolExecutor
创建线程池对象:
ThreadPoolExecutor threadPoolExecutor new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);
代码实现:
package com.itheima.mythreadpool;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo3 {
// 参数一核心线程数量
// 参数二最大线程数
// 参数三空闲线程最大存活时间
// 参数四时间单位
// 参数五任务队列
// 参数六创建线程工厂
// 参数七任务的拒绝策略public static void main(String[] args) {ThreadPoolExecutor pool new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());pool.submit(new MyRunnable());pool.submit(new MyRunnable());pool.shutdown();}
}1.6 线程池 - 参数详解 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueueRunnable workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)corePoolSize 核心线程的最大值不能小于0
maximumPoolSize最大线程数不能小于等于0maximumPoolSize corePoolSize
keepAliveTime 空闲线程最大存活时间,不能小于0
unit 时间单位
workQueue 任务队列不能为null
threadFactory 创建线程工厂,不能为null
handler 任务的拒绝策略,不能为null1.7 线程池 - 非默认任务拒绝策略
RejectedExecutionHandler 是 jdk 提供的一个任务拒绝策略接口它下面存在 4 个子类。
ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy 丢弃任务但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy: 调用任务的run()方法绕过线程池直接执行。注明确线程池对多可执行的任务数 队列容量 最大线程数
案例演示 1演示 ThreadPoolExecutor.AbortPolicy 任务处理策略
public class ThreadPoolExecutorDemo01 {public static void main(String[] args) {/*** 核心线程数量为1 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s*/ThreadPoolExecutor threadPoolExecutor new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,new ArrayBlockingQueue(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;// 提交5个任务而该线程池最多可以处理4个任务当我们使用AbortPolicy这个任务处理策略的时候就会抛出异常for(int x 0 ; x 5 ; x) {threadPoolExecutor.submit(() - {System.out.println(Thread.currentThread().getName() ---- 执行了任务);});}}
}控制台输出结果
pool-1-thread-1---- 执行了任务
pool-1-thread-3---- 执行了任务
pool-1-thread-2---- 执行了任务
pool-1-thread-3---- 执行了任务控制台报错仅仅执行了 4 个任务有一个任务被丢弃了
案例演示 2演示 ThreadPoolExecutor.DiscardPolicy 任务处理策略
public class ThreadPoolExecutorDemo02 {public static void main(String[] args) {/*** 核心线程数量为1 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s*/ThreadPoolExecutor threadPoolExecutor new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,new ArrayBlockingQueue(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;// 提交5个任务而该线程池最多可以处理4个任务当我们使用DiscardPolicy这个任务处理策略的时候控制台不会报错for(int x 0 ; x 5 ; x) {threadPoolExecutor.submit(() - {System.out.println(Thread.currentThread().getName() ---- 执行了任务);});}}
}控制台输出结果
pool-1-thread-1---- 执行了任务
pool-1-thread-1---- 执行了任务
pool-1-thread-3---- 执行了任务
pool-1-thread-2---- 执行了任务控制台没有报错仅仅执行了 4 个任务有一个任务被丢弃了
案例演示 3演示 ThreadPoolExecutor.DiscardOldestPolicy 任务处理策略
public class ThreadPoolExecutorDemo02 {public static void main(String[] args) {/*** 核心线程数量为1 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s*/ThreadPoolExecutor threadPoolExecutor;threadPoolExecutor new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,new ArrayBlockingQueue(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());// 提交5个任务for(int x 0 ; x 5 ; x) {// 定义一个变量来指定指定当前执行的任务;这个变量需要被final修饰final int y x ;threadPoolExecutor.submit(() - {System.out.println(Thread.currentThread().getName() ---- 执行了任务 y);});}}
}控制台输出结果
pool-1-thread-2---- 执行了任务2
pool-1-thread-1---- 执行了任务0
pool-1-thread-3---- 执行了任务3
pool-1-thread-1---- 执行了任务4由于任务 1 在线程池中等待时间最长因此任务 1 被丢弃。
案例演示 4演示 ThreadPoolExecutor.CallerRunsPolicy 任务处理策略
public class ThreadPoolExecutorDemo04 {public static void main(String[] args) {/*** 核心线程数量为1 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s*/ThreadPoolExecutor threadPoolExecutor;threadPoolExecutor new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,new ArrayBlockingQueue(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());// 提交5个任务for(int x 0 ; x 5 ; x) {threadPoolExecutor.submit(() - {System.out.println(Thread.currentThread().getName() ---- 执行了任务);});}}
}控制台输出结果
pool-1-thread-1---- 执行了任务
pool-1-thread-3---- 执行了任务
pool-1-thread-2---- 执行了任务
pool-1-thread-1---- 执行了任务
main---- 执行了任务通过控制台的输出我们可以看到次策略没有通过线程池中的线程执行任务而是直接调用任务的 run() 方法绕过线程池直接执行。
2. 多线程综合练习
练习一售票
需求
一共有 1000 张电影票,可以在两个窗口领取,假设每次领取的时间为 3000 毫秒,
请用多线程模拟卖票过程并打印剩余电影票的数量
代码示例
public class MyThread extends Thread {//第一种方式实现多线程测试类中MyThread会创建多次所以需要加staticstatic int ticket 1000;Overridepublic void run() {//1.循环while (true) {//2.同步代码块synchronized (MyThread.class) {//3.判断共享数据已经到末尾if (ticket 0) {break;} else {//4.判断共享数据没有到末尾try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(getName() 在卖票还剩下 ticket 张票!!!);}}}}
}public class Test {public static void main(String[] args) {/*一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,要求:请用多线程模拟卖票过程并打印剩余电影票的数量*///创建线程对象MyThread t1 new MyThread();MyThread t2 new MyThread();//给线程设置名字t1.setName(窗口1);t2.setName(窗口2);//开启线程t1.start();t2.start();}
}
练习二赠送礼物
需求
有 100 份礼品,两人同时发送当剩下的礼品小于 10 份的时候则不再送出。
利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
public class MyRunable implements Runnable {//第二种方式实现多线程测试类中MyRunable只创建一次所以不需要加staticint count 100;Overridepublic void run() {//1.循环while (true) {//2.同步代码块synchronized (MyThread.class) {//3.判断共享数据已经到末尾if (count 10) {System.out.println(礼物还剩下 count 不再赠送);break;} else {//4.判断共享数据没有到末尾count--;System.out.println(Thread.currentThread().getName() 在赠送礼物还剩下 count 个礼物!!!);}}}}
}public class Test {public static void main(String[] args) {/*有100份礼品,两人同时发送当剩下的礼品小于10份的时候则不再送出利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.*///创建参数对象MyRunable mr new MyRunable();//创建线程对象Thread t1 new Thread(mr,窗口1);Thread t2 new Thread(mr,窗口2);//启动线程t1.start();t2.start();}
}
练习三打印数字
需求
同时开启两个线程共同获取 1-100 之间的所有数字。
将输出所有的奇数。
public class MyRunable implements Runnable {//第二种方式实现多线程测试类中MyRunable只创建一次所以不需要加staticint number 1;Overridepublic void run() {//1.循环while (true) {//2.同步代码块synchronized (MyThread.class) {//3.判断共享数据已经到末尾if (number 100) {break;} else {//4.判断共享数据没有到末尾if(number % 2 1){System.out.println(Thread.currentThread().getName() 打印数字 number);}number;}}}}
}public class Test {public static void main(String[] args) {/*同时开启两个线程共同获取1-100之间的所有数字。要求将输出所有的奇数。*///创建参数对象MyRunable mr new MyRunable();//创建线程对象Thread t1 new Thread(mr,线程A);Thread t2 new Thread(mr,线程B);//启动线程t1.start();t2.start();}
}练习四抢红包
需求
抢红包也用到了多线程。
假设100 块分成了 3 个包现在有 5 个人去抢。
其中红包是共享数据。
5 个人是 5 条线程。
打印结果如下
XXX 抢到了 XXX 元
XXX 抢到了 XXX 元
XXX 抢到了 XXX 元
XXX 没抢到
XXX 没抢到
解决方案一
public class MyThread extends Thread{//共享数据//100块分成了3个包static double money 100;static int count 3;//最小的中奖金额static final double MIN 0.01;Overridepublic void run() {//同步代码块synchronized (MyThread.class){if(count 0){//判断共享数据是否到了末尾已经到末尾System.out.println(getName() 没有抢到红包);}else{//判断共享数据是否到了末尾没有到末尾//定义一个变量表示中奖的金额double prize 0;if(count 1){//表示此时是最后一个红包//就无需随机剩余所有的钱都是中奖金额prize money;}else{//表示第一次第二次随机Random r new Random();//100 元 3个包//第一个红包99.98//100 - (3-1) * 0.01double bounds money - (count - 1) * MIN;prize r.nextDouble(bounds);if(prize MIN){prize MIN;}}//从money当中去掉当前中奖的金额money money - prize;//红包的个数-1count--;//本次红包的信息进行打印System.out.println(getName() 抢到了 prize 元);}}}
}
public class Test {public static void main(String[] args) {/*微信中的抢红包也用到了多线程。假设100块分成了3个包现在有5个人去抢。其中红包是共享数据。5个人是5条线程。打印结果如下XXX抢到了XXX元XXX抢到了XXX元XXX抢到了XXX元XXX没抢到XXX没抢到*///创建线程的对象MyThread t1 new MyThread();MyThread t2 new MyThread();MyThread t3 new MyThread();MyThread t4 new MyThread();MyThread t5 new MyThread();//给线程设置名字t1.setName(小A);t2.setName(小QQ);t3.setName(小哈哈);t4.setName(小诗诗);t5.setName(小丹丹);//启动线程t1.start();t2.start();t3.start();t4.start();t5.start();}
}解决方案二
public class MyThread extends Thread{//总金额static BigDecimal money BigDecimal.valueOf(100.0);//个数static int count 3;//最小抽奖金额static final BigDecimal MIN BigDecimal.valueOf(0.01);Overridepublic void run() {synchronized (MyThread.class){if(count 0){System.out.println(getName() 没有抢到红包);}else{//中奖金额BigDecimal prize;if(count 1){prize money;}else{//获取抽奖范围double bounds money.subtract(BigDecimal.valueOf(count-1).multiply(MIN)).doubleValue();Random r new Random();//抽奖金额prize BigDecimal.valueOf(r.nextDouble(bounds));}//设置抽中红包小数点保留两位四舍五入prize prize.setScale(2,RoundingMode.HALF_UP);//在总金额中去掉对应的钱money money.subtract(prize);//红包少了一个count--;//输出红包信息System.out.println(getName() 抽中了 prize 元);}}}
}public class Test {public static void main(String[] args) {/*微信中的抢红包也用到了多线程。假设100块分成了3个包现在有5个人去抢。其中红包是共享数据。5个人是5条线程。打印结果如下XXX抢到了XXX元XXX抢到了XXX元XXX抢到了XXX元XXX没抢到XXX没抢到*/MyThread t1 new MyThread();MyThread t2 new MyThread();MyThread t3 new MyThread();MyThread t4 new MyThread();MyThread t5 new MyThread();t1.setName(小A);t2.setName(小QQ);t3.setName(小哈哈);t4.setName(小诗诗);t5.setName(小丹丹);t1.start();t2.start();t3.start();t4.start();t5.start();}
}练习五抽奖箱
需求
有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱 (线程) 设置线程名称分别为 抽奖箱 1 抽奖箱 2
随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
每次抽出一个奖项就打印一个 (随机)
抽奖箱 1 又产生了一个 10 元大奖
抽奖箱 1 又产生了一个 100 元大奖
抽奖箱 1 又产生了一个 200 元大奖
抽奖箱 1 又产生了一个 800 元大奖
抽奖箱 2 又产生了一个 700 元大奖
……
public class MyThread extends Thread {ArrayListInteger list;public MyThread(ArrayListInteger list) {this.list list;}Overridepublic void run() {//1.循环//2.同步代码块//3.判断//4.判断while (true) {synchronized (MyThread.class) {if (list.size() 0) {break;} else {//继续抽奖Collections.shuffle(list);int prize list.remove(0);System.out.println(getName() 又产生了一个 prize 元大奖);}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:每次抽出一个奖项就打印一个(随机)抽奖箱1 又产生了一个 10 元大奖抽奖箱1 又产生了一个 100 元大奖抽奖箱1 又产生了一个 200 元大奖抽奖箱1 又产生了一个 800 元大奖抽奖箱2 又产生了一个 700 元大奖.....*///创建奖池ArrayListInteger list new ArrayList();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建线程MyThread t1 new MyThread(list);MyThread t2 new MyThread(list);//设置名字t1.setName(抽奖箱1);t2.setName(抽奖箱2);//启动线程t1.start();t2.start();}
}练习六多线程统计并求最大值
需求
在上一题基础上继续完成如下需求
每次抽的过程中不打印抽完时一次性打印 (随机)
在此次抽奖过程中抽奖箱 1 总共产生了 6 个奖项。
分别为10,20,100,500,2,300 最高奖项为 300 元总计额为 932 元
在此次抽奖过程中抽奖箱 2 总共产生了 6 个奖项。
分别为5,50,200,800,80,700 最高奖项为 800 元总计额为 1835 元
解决方案一
public class MyThread extends Thread {ArrayListInteger list;public MyThread(ArrayListInteger list) {this.list list;}//线程一static ArrayListInteger list1 new ArrayList();//线程二static ArrayListInteger list2 new ArrayList();Overridepublic void run() {while (true) {synchronized (MyThread.class) {if (list.size() 0) {if(抽奖箱1.equals(getName())){System.out.println(抽奖箱1 list1);}else {System.out.println(抽奖箱2 list2);}break;} else {//继续抽奖Collections.shuffle(list);int prize list.remove(0);if(抽奖箱1.equals(getName())){list1.add(prize);}else {list2.add(prize);}}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:每次抽的过程中不打印抽完时一次性打印(随机) 在此次抽奖过程中抽奖箱1总共产生了6个奖项。分别为10,20,100,500,2,300最高奖项为300元总计额为932元在此次抽奖过程中抽奖箱2总共产生了6个奖项。分别为5,50,200,800,80,700最高奖项为800元总计额为1835元*///创建奖池ArrayListInteger list new ArrayList();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建线程MyThread t1 new MyThread(list);MyThread t2 new MyThread(list);//设置名字t1.setName(抽奖箱1);t2.setName(抽奖箱2);//启动线程t1.start();t2.start();}
}
解决方案二
public class MyThread extends Thread {ArrayListInteger list;public MyThread(ArrayListInteger list) {this.list list;}Overridepublic void run() {ArrayListInteger boxList new ArrayList();//1 //2while (true) {synchronized (MyThread.class) {if (list.size() 0) {System.out.println(getName() boxList);break;} else {//继续抽奖Collections.shuffle(list);int prize list.remove(0);boxList.add(prize);}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:每次抽的过程中不打印抽完时一次性打印(随机) 在此次抽奖过程中抽奖箱1总共产生了6个奖项。分别为10,20,100,500,2,300最高奖项为300元总计额为932元在此次抽奖过程中抽奖箱2总共产生了6个奖项。分别为5,50,200,800,80,700最高奖项为800元总计额为1835元*///创建奖池ArrayListInteger list new ArrayList();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建线程MyThread t1 new MyThread(list);MyThread t2 new MyThread(list);//设置名字t1.setName(抽奖箱1);t2.setName(抽奖箱2);//启动线程t1.start();t2.start();}
}练习七多线程之间的比较
需求
在上一题基础上继续完成如下需求
在此次抽奖过程中抽奖箱 1 总共产生了 6 个奖项分别为10,20,100,500,2,300
最高奖项为 300 元总计额为 932 元
在此次抽奖过程中抽奖箱 2 总共产生了 6 个奖项分别为5,50,200,800,80,700
最高奖项为 800 元总计额为 1835 元
在此次抽奖过程中,抽奖箱 2 中产生了最大奖项,该奖项金额为 800 元
以上打印效果只是数据模拟,实际代码运行的效果会有差异
public class MyCallable implements CallableInteger {ArrayListInteger list;public MyCallable(ArrayListInteger list) {this.list list;}Overridepublic Integer call() throws Exception {ArrayListInteger boxList new ArrayList();//1 //2while (true) {synchronized (MyCallable.class) {if (list.size() 0) {System.out.println(Thread.currentThread().getName() boxList);break;} else {//继续抽奖Collections.shuffle(list);int prize list.remove(0);boxList.add(prize);}}Thread.sleep(10);}//把集合中的最大值返回if(boxList.size() 0){return null;}else{return Collections.max(boxList);}}
}package com.itheima.test7;import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Test {public static void main(String[] args) throws ExecutionException, InterruptedException {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为 抽奖箱1, 抽奖箱2随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:在此次抽奖过程中抽奖箱1总共产生了6个奖项分别为10,20,100,500,2,300最高奖项为300元总计额为932元在此次抽奖过程中抽奖箱2总共产生了6个奖项分别为5,50,200,800,80,700最高奖项为800元总计额为1835元在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元核心逻辑获取线程抽奖的最大值看成是线程运行的结果以上打印效果只是数据模拟,实际代码运行的效果会有差异*///创建奖池ArrayListInteger list new ArrayList();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建多线程要运行的参数对象MyCallable mc new MyCallable(list);//创建多线程运行结果的管理者对象//线程一FutureTaskInteger ft1 new FutureTask(mc);//线程二FutureTaskInteger ft2 new FutureTask(mc);//创建线程对象Thread t1 new Thread(ft1);Thread t2 new Thread(ft2);//设置名字t1.setName(抽奖箱1);t2.setName(抽奖箱2);//开启线程t1.start();t2.start();Integer max1 ft1.get();Integer max2 ft2.get();System.out.println(max1);System.out.println(max2);//在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元if(max1 null){System.out.println(在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为max2元);}else if(max2 null){System.out.println(在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为max1元);}else if(max1 max2){System.out.println(在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为max1元);}else if(max1 max2){System.out.println(在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为max2元);}else{System.out.println(两者的最大奖项是一样的);}}
}2. 原子性
2.1 volatile- 问题
代码分析:
package com.itheima.myvolatile;public class Demo {public static void main(String[] args) {MyThread1 t1 new MyThread1();t1.setName(小路同学);t1.start();MyThread2 t2 new MyThread2();t2.setName(小皮同学);t2.start();}
}package com.itheima.myvolatile;public class Money {public static int money 100000;
}package com.itheima.myvolatile;public class MyThread1 extends Thread {Overridepublic void run() {while(Money.money 100000){}System.out.println(结婚基金已经不是十万了);}
}
package com.itheima.myvolatile;public class MyThread2 extends Thread {Overridepublic void run() {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}Money.money 90000;}
}
程序问题: 女孩虽然知道结婚基金是十万但是当基金的余额发生变化的时候女孩无法知道最新的余额。
2.2 volatile 解决
以上案例出现的问题:
当 A 线程修改了共享数据时B 线程没有及时获取到最新的值如果还在使用原先的值就会出现问题
1堆内存是唯一的每一个线程都有自己的线程栈。
2每一个线程在使用堆里面变量的时候都会先拷贝一份到变量的副本中。
3在线程中每一次使用是从变量的副本中获取的。
Volatile 关键字: 强制线程每次在使用的时候都会看一下共享区域最新的值
代码实现: 使用 volatile 关键字解决
package com.itheima.myvolatile;public class Demo {public static void main(String[] args) {MyThread1 t1 new MyThread1();t1.setName(小路同学);t1.start();MyThread2 t2 new MyThread2();t2.setName(小皮同学);t2.start();}
}package com.itheima.myvolatile;public class Money {public static volatile int money 100000;
}package com.itheima.myvolatile;public class MyThread1 extends Thread {Overridepublic void run() {while(Money.money 100000){}System.out.println(结婚基金已经不是十万了);}
}
package com.itheima.myvolatile;public class MyThread2 extends Thread {Overridepublic void run() {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}Money.money 90000;}
}
2.3 synchronized 解决
synchronized 解决:
1线程获得锁
2清空变量副本
3拷贝共享变量最新的值到变量副本中
4执行代码
5将修改后变量副本中的值赋值给共享数据
6释放锁
代码实现:
package com.itheima.myvolatile2;public class Demo {public static void main(String[] args) {MyThread1 t1 new MyThread1();t1.setName(小路同学);t1.start();MyThread2 t2 new MyThread2();t2.setName(小皮同学);t2.start();}
}package com.itheima.myvolatile2;public class Money {public static Object lock new Object();public static volatile int money 100000;
}package com.itheima.myvolatile2;public class MyThread1 extends Thread {Overridepublic void run() {while(true){synchronized (Money.lock){if(Money.money ! 100000){System.out.println(结婚基金已经不是十万了);break;}}}}
}package com.itheima.myvolatile2;public class MyThread2 extends Thread {Overridepublic void run() {synchronized (Money.lock) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}Money.money 90000;}}
}2.4 原子性
概述: 所谓的原子性是指在一次操作或者多次操作中要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断要么所有的操作都不执行多个操作是一个不可以分割的整体。
代码实现:
package com.itheima.threadatom;public class AtomDemo {public static void main(String[] args) {MyAtomThread atom new MyAtomThread();for (int i 0; i 100; i) {new Thread(atom).start();}}
}
class MyAtomThread implements Runnable {private volatile int count 0; //送冰淇淋的数量Overridepublic void run() {for (int i 0; i 100; i) {//1,从共享数据中读取数据到本线程栈中.//2,修改本线程栈中变量副本的值//3,会把本线程栈中变量副本的值赋值给共享数据.count;System.out.println(已经送了 count 个冰淇淋);}}
}代码总结: count 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断
2.5 volatile 关键字不能保证原子性
解决方案: 我们可以给 count 操作添加锁那么 count 操作就是临界区中的代码临界区中的代码一次只能被一个线程去执行所以 count 就变成了原子操作。
package com.itheima.threadatom2;public class AtomDemo {public static void main(String[] args) {MyAtomThread atom new MyAtomThread();for (int i 0; i 100; i) {new Thread(atom).start();}}
}
class MyAtomThread implements Runnable {private volatile int count 0; //送冰淇淋的数量private Object lock new Object();Overridepublic void run() {for (int i 0; i 100; i) {//1,从共享数据中读取数据到本线程栈中.//2,修改本线程栈中变量副本的值//3,会把本线程栈中变量副本的值赋值给共享数据.synchronized (lock) {count;System.out.println(已经送了 count 个冰淇淋);}}}
}2.6 原子性_AtomicInteger
概述java 从 JDK1.5 开始提供了 java.util.concurrent.atomic 包 (简称 Atomic 包)这个包中的原子操作类提供了一种用法简单性能高效线程安全地更新一个变量的方式。因为变
量的类型有很多种所以在 Atomic 包里一共提供了 13 个类属于 4 种类型的原子更新方式分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性 (字段)。本次我们只讲解
使用原子的方式更新基本类型使用原子的方式更新基本类型 Atomic 包提供了以下 3 个类
AtomicBoolean原子更新布尔类型
AtomicInteger原子更新整型
AtomicLong原子更新长整型
以上 3 个类提供的方法几乎一模一样所以本节仅以 AtomicInteger 为例进行讲解AtomicInteger 的常用方法如下
public AtomicInteger() 初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue) 初始化一个指定值的原子型Integerint get(): 获取值
int getAndIncrement(): 以原子方式将当前值加1注意这里返回的是自增前的值。
int incrementAndGet(): 以原子方式将当前值加1注意这里返回的是自增后的值。
int addAndGet(int data): 以原子方式将输入的数值与实例中的值AtomicInteger里的value相加并返回结果。
int getAndSet(int value): 以原子方式设置为newValue的值并返回旧值。代码实现:
package com.itheima.threadatom3;import java.util.concurrent.atomic.AtomicInteger;public class MyAtomIntergerDemo1 {
// public AtomicInteger() 初始化一个默认值为0的原子型Integer
// public AtomicInteger(int initialValue) 初始化一个指定值的原子型Integerpublic static void main(String[] args) {AtomicInteger ac new AtomicInteger();System.out.println(ac);AtomicInteger ac2 new AtomicInteger(10);System.out.println(ac2);}}package com.itheima.threadatom3;import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;public class MyAtomIntergerDemo2 {
// int get(): 获取值
// int getAndIncrement(): 以原子方式将当前值加1注意这里返回的是自增前的值。
// int incrementAndGet(): 以原子方式将当前值加1注意这里返回的是自增后的值。
// int addAndGet(int data): 以原子方式将参数与对象中的值相加并返回结果。
// int getAndSet(int value): 以原子方式设置为newValue的值并返回旧值。public static void main(String[] args) {
// AtomicInteger ac1 new AtomicInteger(10);
// System.out.println(ac1.get());// AtomicInteger ac2 new AtomicInteger(10);
// int andIncrement ac2.getAndIncrement();
// System.out.println(andIncrement);
// System.out.println(ac2.get());// AtomicInteger ac3 new AtomicInteger(10);
// int i ac3.incrementAndGet();
// System.out.println(i);//自增后的值
// System.out.println(ac3.get());// AtomicInteger ac4 new AtomicInteger(10);
// int i ac4.addAndGet(20);
// System.out.println(i);
// System.out.println(ac4.get());AtomicInteger ac5 new AtomicInteger(100);int andSet ac5.getAndSet(20);System.out.println(andSet);System.out.println(ac5.get());}
}2.7 AtomicInteger- 内存解析
AtomicInteger 原理: 自旋锁 CAS 算法
CAS 算法
有 3 个操作数内存值 V旧的预期值 A要修改的值 B
当旧的预期值 A 内存值 此时修改成功将 V 改为 B
当旧的预期值 A内存值 此时修改失败不做任何操作
并重新获取现在的最新值这个重新获取的动作就是自旋
2.8 AtomicInteger- 源码解析
代码实现:
package com.itheima.threadatom4;public class AtomDemo {public static void main(String[] args) {MyAtomThread atom new MyAtomThread();for (int i 0; i 100; i) {new Thread(atom).start();}}
}package com.itheima.threadatom4;import java.util.concurrent.atomic.AtomicInteger;public class MyAtomThread implements Runnable {//private volatile int count 0; //送冰淇淋的数量//private Object lock new Object();AtomicInteger ac new AtomicInteger(0);Overridepublic void run() {for (int i 0; i 100; i) {//1,从共享数据中读取数据到本线程栈中.//2,修改本线程栈中变量副本的值//3,会把本线程栈中变量副本的值赋值给共享数据.//synchronized (lock) {
// count;
// ac;int count ac.incrementAndGet();System.out.println(已经送了 count 个冰淇淋);// }}}
}
源码解析: //先自增然后获取自增后的结果
public final int incrementAndGet() {// 1 自增后的结果//this 就表示当前的atomicInteger值//1 自增一次return U.getAndAddInt(this, VALUE, 1) 1;
}public final int getAndAddInt(Object o, long offset, int delta) {//v 旧值int v;//自旋的过程do {//不断的获取旧值v getIntVolatile(o, offset);//如果这个方法的返回值为false那么继续自旋//如果这个方法的返回值为true那么自旋结束//o 表示的就是内存值//v 旧值//v delta 修改后的值} while (!weakCompareAndSetInt(o, offset, v, v delta));//作用比较内存中的值旧值是否相等如果相等就把修改后的值写到内存中返回true。表示修改成功。// 如果不相等无法把修改后的值写到内存中返回false。表示修改失败。//如果修改失败那么继续自旋。return v;
}2.9 悲观锁和乐观锁
synchronized 和 CAS 的区别:
**相同点**在多线程情况下都可以保证共享数据的安全性。
**不同点**synchronized 总是从最坏的角度出发认为每次获取数据的时候别人都有可能修改。所以在每 次操作共享数据之前都会上锁。悲观锁
cas 是从乐观的角度出发假设每次获取数据别人都不会修改所以不会上锁。只不过在修改共享数据的时候会检查一下别人有没有修改过这个数据。
如果别人修改过那么我再次获取现在最新的值。
如果别人没有修改过那么我现在直接修改共享数据的值.(乐观锁
3. 并发工具类
3.1 并发工具类 -Hashtable
Hashtable 出现的原因: 在集合类中 HashMap 是比较常用的集合对象但是 HashMap 是线程不安全的 (多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用 Hashtable但是 Hashtable 的效率低下。
代码实现:
package com.itheima.mymap;import java.util.HashMap;
import java.util.Hashtable;public class MyHashtableDemo {public static void main(String[] args) throws InterruptedException {HashtableString, String hm new Hashtable();Thread t1 new Thread(() - {for (int i 0; i 25; i) {hm.put(i , i );}});Thread t2 new Thread(() - {for (int i 25; i 51; i) {hm.put(i , i );}});t1.start();t2.start();System.out.println(----------------------------);//为了t1和t2能把数据全部添加完毕Thread.sleep(1000);//0-0 1-1 ..... 50- 50for (int i 0; i 51; i) {System.out.println(hm.get(i ));}//0 1 2 3 .... 50}
}3.2 并发工具类 -ConcurrentHashMap 基本使用
ConcurrentHashMap 出现的原因: 在集合类中 HashMap 是比较常用的集合对象但是 HashMap 是线程不安全的 (多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用 Hashtable但是 Hashtable 的效率低下。
基于以上两个原因我们可以使用 JDK1.5 以后所提供的 ConcurrentHashMap。
体系结构: 总结:
1HashMap 是线程不安全的。多线程环境下会有数据安全问题
2Hashtable 是线程安全的但是会将整张表锁起来效率低下
3ConcurrentHashMap 也是线程安全的效率较高。在 JDK7 和 JDK8 中底层原理不一样。
代码实现:
package com.itheima.mymap;import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;public class MyConcurrentHashMapDemo {public static void main(String[] args) throws InterruptedException {ConcurrentHashMapString, String hm new ConcurrentHashMap(100);Thread t1 new Thread(() - {for (int i 0; i 25; i) {hm.put(i , i );}});Thread t2 new Thread(() - {for (int i 25; i 51; i) {hm.put(i , i );}});t1.start();t2.start();System.out.println(----------------------------);//为了t1和t2能把数据全部添加完毕Thread.sleep(1000);//0-0 1-1 ..... 50- 50for (int i 0; i 51; i) {System.out.println(hm.get(i ));}//0 1 2 3 .... 50}
}3.3 并发工具类 -ConcurrentHashMap1.7 原理 3.4 并发工具类 -ConcurrentHashMap1.8 原理 总结:
1如果使用空参构造创建 ConcurrentHashMap 对象则什么事情都不做。在第一次添加元素的时候创建哈希表
2计算当前元素应存入的索引。
3如果该索引位置为 null则利用 cas 算法将本结点添加到数组中。
4如果该索引位置不为 null则利用 volatile 关键字获得当前位置最新的结点地址挂在他下面变成链表。
5当链表的长度大于等于 8 时自动转换成红黑树 6以链表或者红黑树头结点为锁对象配合悲观锁保证多线程操作集合时数据的安全性
3.5 并发工具类 -CountDownLatch
CountDownLatch 类:
方法解释public CountDownLatch(int count)参数传递线程数表示等待线程数量public void await()让线程等待public void countDown()当前线程执行完毕
使用场景 让某一条线程等待其他线程执行完毕之后再执行
代码实现:
package com.itheima.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChileThread1 extends Thread {private CountDownLatch countDownLatch;public ChileThread1(CountDownLatch countDownLatch) {this.countDownLatch countDownLatch;}Overridepublic void run() {//1.吃饺子for (int i 1; i 10; i) {System.out.println(getName() 在吃第 i 个饺子);}//2.吃完说一声//每一次countDown方法的时候就让计数器-1countDownLatch.countDown();}
}
package com.itheima.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChileThread2 extends Thread {private CountDownLatch countDownLatch;public ChileThread2(CountDownLatch countDownLatch) {this.countDownLatch countDownLatch;}Overridepublic void run() {//1.吃饺子for (int i 1; i 15; i) {System.out.println(getName() 在吃第 i 个饺子);}//2.吃完说一声//每一次countDown方法的时候就让计数器-1countDownLatch.countDown();}
}
package com.itheima.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class ChileThread3 extends Thread {private CountDownLatch countDownLatch;public ChileThread3(CountDownLatch countDownLatch) {this.countDownLatch countDownLatch;}Overridepublic void run() {//1.吃饺子for (int i 1; i 20; i) {System.out.println(getName() 在吃第 i 个饺子);}//2.吃完说一声//每一次countDown方法的时候就让计数器-1countDownLatch.countDown();}
}
package com.itheima.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class MotherThread extends Thread {private CountDownLatch countDownLatch;public MotherThread(CountDownLatch countDownLatch) {this.countDownLatch countDownLatch;}Overridepublic void run() {//1.等待try {//当计数器变成0的时候会自动唤醒这里等待的线程。countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}//2.收拾碗筷System.out.println(妈妈在收拾碗筷);}
}
package com.itheima.mycountdownlatch;import java.util.concurrent.CountDownLatch;public class MyCountDownLatchDemo {public static void main(String[] args) {//1.创建CountDownLatch的对象需要传递给四个线程。//在底层就定义了一个计数器此时计数器的值就是3CountDownLatch countDownLatch new CountDownLatch(3);//2.创建四个线程对象并开启他们。MotherThread motherThread new MotherThread(countDownLatch);motherThread.start();ChileThread1 t1 new ChileThread1(countDownLatch);t1.setName(小明);ChileThread2 t2 new ChileThread2(countDownLatch);t2.setName(小红);ChileThread3 t3 new ChileThread3(countDownLatch);t3.setName(小刚);t1.start();t2.start();t3.start();}
}总结:
1. CountDownLatch(int count)参数写等待线程的数量。并定义了一个计数器。
2. await()让线程等待当计数器为 0 时会唤醒等待的线程
3. countDown()线程执行完毕时调用会将计数器 -1。
3.6 并发工具类 -Semaphore
使用场景:
可以控制访问特定资源的线程数量。
实现步骤:
1需要有人管理这个通道
2当有车进来了发通行许可证
3当车出去了收回通行许可证
4如果通行许可证发完了那么其他车辆只能等着
代码实现:
package com.itheima.mysemaphore;import java.util.concurrent.Semaphore;public class MyRunnable implements Runnable {//1.获得管理员对象private Semaphore semaphore new Semaphore(2);Overridepublic void run() {//2.获得通行证try {semaphore.acquire();//3.开始行驶System.out.println(获得了通行证开始行驶);Thread.sleep(2000);System.out.println(归还通行证);//4.归还通行证semaphore.release();} catch (InterruptedException e) {e.printStackTrace();}}
}
package com.itheima.mysemaphore;public class MySemaphoreDemo {public static void main(String[] args) {MyRunnable mr new MyRunnable();for (int i 0; i 100; i) {new Thread(mr).start();}}
}
