重难点梳理
知识点梳理
学习目标
2、能够理解什么是线程池(概述，Executors方式创建线程池，ThreadPoolExecutor方式创建线程池，线程池原理说明)
3、能够了解volatile关键字的语义（特点）
4、能够知道什么是原子性(原子性概述，常见原子类的使用，CAS算法)
5、能够掌握jdk中提供的线程并发工具类的使用（ConcurrentHashMap，CountDownLatch，Semaphore）
超详细讲义
1.线程状态
3.volatile
4.原子性
5.并发工具包
1. 线程状态介绍 【记忆】
(共3点)
1.线程状态介绍
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态,同一时刻线程只能存于一种状态
2.各个状态的转换，如下图所示：
3.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 | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
2.线程池
2.1 线程池-基本原理 【难点】
（共3点）
1.什么是线程池？
存线程的容器就是线程池
2.线程池的原理？
==3.为什么要使用线程池？==
用少量的线程执行更多的任务，提高线程的利用率
2.2 线程池-Executors默认线程池 【了解】
1.如何创建线程池？
使用Executors中所提供的静态方法来创建线程池
static ExecutorService newCachedThreadPool() 创建一个默认的线程池 static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
2.如何把线程放到线程池中？（ExecutorServicer）
| 方法 | 说明 |
|---|---|
| Future<?> submit(Runnable task | 提交一个可运行的任务执行，并返回一个表示该任务的未来。 |
3.如何关闭线程池？
| 方法 | 说明 |
|---|---|
| void shutdown() | 关闭线程池，先前提交的任务将被执行，但不会接受任何新任务 |
代码实现 :
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();//关闭后不能再提交了，因此后面的代码会报错
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
}
}
2.3 线程池-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());//0
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
System.out.println(pool.getPoolSize());//2
// executorService.shutdown();
}
}
==如果线程执行完没有返回值，未来的get方法将在成功完成后返回null；如果线程执行完有返回值，未来的get方法将在成功完成后返回线程执行完的返回值==
2.4 线程池-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 {
// 参数一：核心线程数量---正式员工 --不能小于0--
// 参数二：最大线程数--- 餐厅最大员工数 --不能小于0，最大数量>=核心线程数量--
// 参数三：空闲线程最大存活时间--- 临时员工空闲多长时间被辞退(值) --不能小于0--
// 参数四：时间单位 ---临时员工空闲多长时间被辞退(单位) --时间单位--
// 参数五：任务队列 ---排队的客户 --不能为null--
// 参数六：创建线程工厂 ---从哪里招人 --不能为null--
// 参数七：任务的拒绝策略 ---排队的人过多，超出顾客请下次再来(拒绝服务) --不能为null--
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();
}
}
2.5 线程池-参数详解 【难点】
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 MyThreadPoolDemo4 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位---TimeUnit
// 参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
// 参数六：创建线程工厂 --- 按照默认的方式创建线程对象
// 参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当线程池中没有空闲线程，并且队列已满时
//2.如何拒绝？ 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
5,
2,TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 16; i++) {
pool.submit(new MyRunnable());
}
pool.shutdown();
}
}
2.拒绝策略
3.默认拒绝策略
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 MyThreadPoolDemo4 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位---TimeUnit
// 参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
// 参数六：创建线程工厂 --- 按照默认的方式创建线程对象
// 参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当同时需要被执行的任务 > 池子中最大的线程数量+队列的容量
//2.如何拒绝？ 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
5,
2,TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 10; i++) {
pool.submit(new MyRunnable());
}
pool.shutdown();
}
}
2.6线程池-非默认任务拒绝策略 【了解】
RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。
ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy： 丢弃任务，但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy： 抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy: 调用任务的run()方法绕过线程池直接执行。
注意：明确线程池最多可执行的任务数 = 队列容量 + 最大线程数
案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略
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 MyThreadPoolDemo5 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位---TimeUnit
// 参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
// 参数六：创建线程工厂 --- 按照默认的方式创建线程对象
// 参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
//2.如何拒绝？ 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1,
2,
2,TimeUnit.HOURS,
new ArrayBlockingQueue<>(1),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy());
for (int i = 1; i < 5; i++) {
int y=i;
pool.submit(()->{
System.out.println(Thread.currentThread().getName()+"---"+y);
});
}
pool.shutdown();
}
}
案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略
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 MyThreadPoolDemo6 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位---TimeUnit
// 参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
// 参数六：创建线程工厂 --- 按照默认的方式创建线程对象
// 参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
//2.如何拒绝？ 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1,
2,
2,TimeUnit.HOURS,
new ArrayBlockingQueue<>(1),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 1; i <= 10; i++) {
int y=i;
pool.submit(()->{
System.out.println(Thread.currentThread().getName()+"---"+y);
});
}
pool.shutdown();
}
}
案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略
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 MyThreadPoolDemo7 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位---TimeUnit
// 参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
// 参数六：创建线程工厂 --- 按照默认的方式创建线程对象
// 参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
//2.如何拒绝？ 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1,
2,
2,TimeUnit.HOURS,
new ArrayBlockingQueue<>(1),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 1; i <= 10; i++) {
int y=i;
pool.submit(()->{
System.out.println(Thread.currentThread().getName()+"---"+y);
});
}
pool.shutdown();
}
}
3. volatile
3.1 volatile-问题 【了解】
代码分析 :
package com.itheima.myvolatile2;
public class Money {
public static int money = 100000;
}
package com.itheima.myvolatile2;
public class MyThread1 extends Thread {
package com.itheima.myvolatile2;
public class MyThread2 extends Thread {
程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。
3.2 volatile解决 【重点】
1.volatile的特点：
每一次使用volatile关键字修饰的变量时，都会看一看内存中的最新值
代码实现 : 使用volatile关键字解决
package com.itheima.myvolatile;
public class Money {
public static volatile int money = 100000;
}
package com.itheima.myvolatile;
public class MyThread1 extends Thread {
package com.itheima.myvolatile;
public class MyThread2 extends Thread {
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();
}
}
3.3 synchronized解决 【重点】
1.synchronized线程执行互斥代码的过程:
1 ，线程获得锁
2 ，清空变量副本
3 ，拷贝共享变量最新的值到变量副本中
4 ，执行代码
5 ，将修改后变量副本中的值赋值给共享数据
6 ，释放锁
代码实现 :
package com.itheima.myvolatile;
public class Money {
public static volatile int money = 100000;
}
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 {
@Override
public void run() {
while(true){
if(Money.money != 100000){
System.out.println("结婚基金已经不是十万了");
break;
}
}
}
}
package com.itheima.myvolatile2;
public class MyThread2 extends Thread {
@Override
public void run() {
synchronized (Money.lock) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
Money.money = 90000;
}
}
}
4.原子性
4.1 原子性 【了解】
（共2点）
1.什么是原子性
所谓的原子性就是完成功能的所有操作要么都执行，要么都不执行
代码实现 :
package com.itheima.threadatom;
public class MyAtomThread implements Runnable {
private volatile int count = 0; //送冰淇淋的数量
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
count++;
System.out.println("已经送了" + count + "个冰淇淋");
}
}
}
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();
}
}
}
代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断
4.2 volatile关键字不能保证原子性【了解】
1.volatile关键字不能保证原子性的原因分析
2.java中如何保证原子性操作？
-
使用锁
-
利用原子类(后面讲解)
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();
}
}
}
package com.itheima.threadatom2;
public class MyAtomThread implements Runnable {
private volatile int count = 0; //送冰淇淋的数量
private Object lock = new Object();
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
synchronized (lock) {
count++;
System.out.println("已经送了" + count + "个冰淇淋");
}
}
}
}
4.3 原子性_AtomicInteger 【重点】
1.什么是原子类?
原子类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式
2.如何使用原子的方式更新基本类型？
使用原子的方式更新基本类型,atomic包提供了：
AtomicInteger： 原子更新整型
3.AtomicInteger的常用方法：
| 方法 | 说明 |
|---|---|
| public AtomicInteger() | 初始化一个默认值为0的原子型Integer |
| public AtomicInteger(int initialValue) | 初始化一个指定值的原子型Integer |
| int 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)： 初始化一个指定值的原子型Integer
public 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());
}
}
4.4 AtomicInteger-内存解析【难点】
AtomicInteger原理 : 自旋锁 + CAS 算法
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);
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
//synchronized (lock) {
// count++;
// ac++;
int count = ac.incrementAndGet();
System.out.println("已经送了" + count + "个冰淇淋");
// }
}
}
}
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();
}
}
}
4.5 AtomicInteger-源码解析【了解】
//当前主内存中的地址
private volatile int value;
//先自增，然后获取自增后的结果
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;
}
4.6 悲观锁和乐观锁【了解】
synchronized和CAS的区别 :
相同点：在多线程情况下，都可以保证共享数据的安全性。
不同点：
synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）
cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。
如果别人修改过，那么我再次获取现在最新的值。
如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）
jdk1.6 synchronized(偏向锁，轻量锁(cas),重量级锁(悲观锁)) ，cas
5. 并发工具包
5.1 并发容器-Hashtable 【重点】
（共3点)
1.为什么要使用Hashtable
在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。
2.Hashtable的原理?
3.HashTable的特点?
1.Hashtable采取悲观锁synchronized的形式保证数据的安全性
2.只要有线程访问，会将整张表全部锁起来,所以Hashtable效率低下
代码实现 :
package com.itheima.mymap;
import java.util.HashMap;
import java.util.Hashtable;
public class MyHashtableDemo {
public static void main(String[] args) throws InterruptedException {
Hashtable<String, 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- 50
for (int i = 0; i < 51; i++) {
System.out.println(hm.get(i + ""));
}//0 1 2 3 .... 50
}
}
5.2 并发容器-ConcurrentHashMap基本使用【重点】
（共3点）
1.为什么要使用ConcurrentHashMap?
为了保证数据的安全性也要考虑效率的情况下,JDK1.5以后所提供ConcurrentHashMap。
2.什么是ConcurrentHashMap？
体系结构 :
3.三种Map结构的对比
1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题
2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下
3，ConcurrentHashMap也是线程安全的，效率较高。 在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 {
ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>();
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- 50
for (int i = 0; i < 51; i++) {
System.out.println(hm.get(i + ""));
}//0 1 2 3 .... 50
}
}
5.3 并发工具类-ConcurrentHashMap1.7原理 【了解】（视频19 12‘’）
3.4 并发容器-ConcurrentHashMap1.8原理【了解】（视频20 10‘’）
总结 :
1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表
2，计算当前元素应存入的索引。
3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。
4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。
5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性
5.5 并发工具类-CountDownLatch【重点】(视频21 12‘’)
1.CountDownLatch的应用场景
让某一条线程等待其他线程执行完毕之后再执行
2.CountDownLatch类中常用的方法 :
| 方法 | 解释 |
|---|---|
| public CountDownLatch(int count) | 参数传递线程数，表示等待线程数量。并定义一个计数器 |
| public void await() | 让线程等待,当计数器为0时，会唤醒等待的线程 |
| public void countDown() | 当前线程执行完毕时，会将计数器-1 |
3.原理
-
CountDownLatch是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。
eg：CountDownLatch c = new CountDownLatch(10); // 等待线程的数量为10
-
线程调用CountDownLatch的await()方法会阻塞当前线程(即:主线程在闭锁上等待)，直到计数器的值为0。
-
当一个工作线程完成了自己的任务后，调用CountDownLatch的countDown()方法，计数器的值就会减1。
-
当计数器值为0时，说明所有的工作线程都执行完了，此时，在闭锁上等待的主线程就可以恢复执行任务
代码实现 :
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class ChileThread1 extends Thread {
private CountDownLatch countDownLatch;
public ChileThread1(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
//1.吃饺子
for (int i = 1; i <= 10; i++) {
System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.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;
}
@Override
public void run() {
//1.吃饺子
for (int i = 1; i <= 15; i++) {
System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.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;
}
@Override
public void run() {
//1.吃饺子
for (int i = 1; i <= 20; i++) {
System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.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;
}
@Override
public 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的对象，需要传递给四个线程。
//在底层就定义了一个计数器，此时计数器的值就是3
CountDownLatch 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();
}
}
5.6 并发工具类-Semaphore 【重点】
1.Semaphore类的应用场景？
可以控制访问特定资源的线程数量。
2.原理
-
Semaphore是通过一个计数器(记录许可证的数量)来实现的，计数器的初始值为需要等待线程的数量
-
eg：Semaphore s = new Semaphore(10); // 线程最大的并发数为10
-
线程通过acquire()方法获取许可证(计数器的值减1)，只有获取到许可证才可以继续执行下去，否则阻塞当前线程
-
线程通过release()方法归还许可证(计数器的值加1)
代码实现 :
package com.itheima.mysemaphore;
import java.util.concurrent.Semaphore;
public class MyRunnable implements Runnable {
//1.获得管理员对象，
private Semaphore semaphore=new Semaphore(2) ;
@Override
public 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();
}
}
}
扩展练习
题目1
请利用线程间通信, 完成连续打印1-100的数字, 要求一条线程专门打印奇数,另外一条专门用来打印偶数
要求:
1:数字打印必须是有序的,既1--100的顺序不能乱;
2:必须使用多线程技术;
效果:
........................
参考答案:
类1:
package day14.No_1;
public class Num {
public static int num=1;
public static Object look=new Object() ;
}
package day14.No_1;
public class Ji implements Runnable {
类3:
package day14.No_1;
public class Ou implements Runnable {
测试类:
package day14.No_1;
public class Test {
public static void main(String[] args) {
Ji j = new Ji();
Ou o = new Ou();
new Thread(j).start();
new Thread(o).start();
}
}
运行效果:
题目2
假如某班级有10人,早晨老师来到教室之后,需要等待10位学生都到齐了才会开始上课,如果10位学生还没有到齐,老师需要一直等待;假如把老师和每一个学生都看成是一个独立的线程,请使用代码模拟这个老师上课的场景;
要求:
1:老师上课之前,打印老师准备就绪,等所有学生到齐之后,老师打印开始讲课;
2:只有10个学生都到了,老师才可以上课;
效果:
参考答案:
学生类:
package day14.No_2;
import java.util.concurrent.CountDownLatch;
public class Student implements Runnable {
private CountDownLatch countDownLatch;
public Student(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
教师类:
package day14.No_2;
import java.util.concurrent.CountDownLatch;
public class Teacher implements Runnable {
private CountDownLatch countDownLatch;
public Teacher(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
测试类:
package day14.No_2;
import java.util.concurrent.CountDownLatch;
public class Test {
public static void main(String[] args) {
CountDownLatch countDownLatch = new CountDownLatch(10);
Teacher teachertast = new Teacher(countDownLatch);
Student studenttast = new Student(countDownLatch);
for (int i = 1; i <= 10; i++) {
new Thread(studenttast, "学生" + i).start();
}
new Thread(teachertast).start();
}
}
运行效果:
题目3[业务比较复杂,有难度呦]
假如现在有一辆公交车,车上有两个乘务员,一个专门负责让乘客上车,并提示目前车上的人数,另一个乘务员专门负责乘客下车,并提示乘客下车后,目前车上的人数,请使用代码模拟这个场景;
要求:
1:公交车最多乘坐30位乘客,如果超过30人,则上车的乘务员不再安排乘客上车,会一直等待,直到车上有空位子再安排乘客上车;
2:如果车上乘客数量为0了,则不再乘客下车,直到车上有乘客,再继续安排乘客下车;
3:每次上下车的人数采用随机数的方式表示上车的人数和下车的人数,且上车时,1次最多上当前最大空余座位数,最少是1人,下车时,1次最多下当前车上总乘客数,最少是1人;
效果:
参考答案:
类1:
package day14.No_3;
public class Chengwu {
public static int count = 30;
public static Object lock = new Object();
}
类2:
package day14.No_3;
import java.util.Random;
public class GetOff implements Runnable {
类3:
package day14.No_3;
import java.util.Random;
public class GetOn implements Runnable {
测试类:
package day14.No_3;
public class Test {
public static void main(String[] args) {
GetOn getOn = new GetOn();
GetOff getOff = new GetOff();
Thread t1 = new Thread(getOn);
Thread t2 = new Thread(getOff);
t1.start();
t2.start();
}
}
运行效果:
