Java教程
2022-08-04 第五组 罗大禹 学习笔记
20220801 第五小组 罗大禹 学习笔记
Java 多线程 Lock
学习重点
1.Lock锁
2.线程池
学习内容
Java 多线程 Lock
LockSupport工具类
线程阻塞的工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有唤醒的方法
-
park: 如果我们把Thread看成一辆车,park就是让车停下来
-
unpark: 就是让车启动,然后跑起来
这里的park和unpark其实实现了wait和notify的功能
区别：
-
park不需要获取某个对象的锁（不释放锁）
-
因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态,然后做额外的处理
总结：
-
park和unpark可以实现wait和notify的功能，但是并不能和wait和notify交叉使用
-
park和unpark不会出现死锁的情况
-
getBlocker的作用，我们可以看到阻塞的对象的信息（park()方法中传的实参）
举例说明：
import java.util.concurrent.locks.LockSupport;
public class Ch01 {
public static final Object OBJ = new Object();
public static void main(String[] args) {
Runnable runnable = () -> {
synchronized (OBJ) {
System.out.println("线程【"+Thread.currentThread().getName()+"】正在执行...");
// 阻塞
LockSupport.park();
if (Thread.currentThread().isInterrupted()) {
System.out.println("被中断了...");
}
System.out.println("继续执行...");
}
};
Thread t1 = new Thread(runnable,"线程一");
Thread t2 = new Thread(runnable,"线程二");
t1.start();
t2.start();
}
}
Lock锁
Lock是一个接口
键盘输入，打印输出极其耗资源IO操作。这两种在实际开发中绝对不允许使用！！！
synchronized和Lock的区别：
-
Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的。
-
synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁。
-
Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
-
Lock可以提高多个线程进行读操作的效率。
举例：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class Ch02 {
public void show() {
Lock lock = new Lock() {
@Override
public void lock() {
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
}
@Override
public Condition newCondition() {
return null;
}
};
// 加锁
lock.lock();
try {
// 正常处理业务逻辑
// 输入输出的操作IO操作
// 操作的是物理内存
// 多线程是内存操作
System.out.println();
}catch (Exception e){
// 当出现异常的解决方案
}finally { // 释放资源，关闭连接，关闭输入输出流
// 手动释放锁
lock.unlock();
}
}
public void info() {
Lock lock = new Lock() {
@Override
public void lock() {
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
}
@Override
public Condition newCondition() {
return null;
}
};
// 如果拿到了锁
if(lock.tryLock()){
try {
// 正常处理业务逻辑
}catch (Exception e){
// 当出现异常的解决方案
}finally { // 释放资源，关闭连接，关闭输入输出流
// 手动释放锁
lock.unlock();
}
}else {
// 如果没有拿到锁，则直接做另外的事情
}
}
public static void main(String[] args) {
}
}
Lock接口的实现类ReentrantLock
ReentrantLock可重入锁。实现了Lock接口
举例说明：
import java.util.concurrent.locks.ReentrantLock;
class Ticket implements Runnable {
private static final ReentrantLock lock = new ReentrantLock();
private static Integer count = 100;
String name;
public Ticket(String name) {
this.name = name;
}
@Override
public void run() {
while(Ticket.count > 0){
lock.lock();
try {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if(count > 0){
System.out.println(name + "正在卖票，剩余：" + --count + "张！");
}
}finally {
lock.unlock();
}
}
}
}
public class Ch03 {
public static void main(String[] args) {
Ticket t1 = new Ticket("窗口一");
Ticket t2 = new Ticket("窗口二");
Ticket t3 = new Ticket("窗口三");
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
}
}
Lock以下功能是synchronized不具备的！
ReentrantReadWriteLock：
对于一个应用而言，一般情况下读操作远远多于写的操作，如果仅仅是读的操作没有写的操作，数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程写，写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。
在某些场景下能极大的提升效率！！！
举例说明：
import java.util.Random;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Ch04 {
private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private static int count = 1;
public static void main(String[] args) {
Runnable read = () -> {
// 创建了一个读锁
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
readLock.lock();
try {
Thread.sleep(2000);
System.out.println("我在读数据：" + count);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
readLock.unlock();
}
};
Runnable write = () -> {
// 创建了一个写锁
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
writeLock.lock();
try {
Thread.sleep(2000);
System.out.println("我在写数据：" + count++);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
writeLock.unlock();
}
};
for (int i = 0; i < 100; i++) {
Random random = new Random();
int flag = random.nextInt(100);
System.out.println("生成的随机整数：" + flag);
if(flag > 20){
new Thread(read).start();
}else {
new Thread(write).start();
}
}
}
}
Lock锁的原理cas和aqs
synchronized是由C语言实现的，只能作为关键字来使用
java提供了一些并发的编程的包，底层的实现原理cas和aqs
并发编程三大特性：
- 原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，
也不可以被切割只执行其中的一部分，将整个操作视为一个整体。
原子性不仅仅是多行代码，也可能是多条指令。 - 可见性
- 有序性
synchronized lock：可以保证原子性、可见性、有序性。
CAS：compare and swap，比较并交换。JDK11改成了compare and set。
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS：抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表
JUC并发编程包
java.util.concurrent.atomic下
1.原子类Atomic
基本类型
AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类
数组类型
AtomicLongArray：长整型数组原子类
AtomicIntegerArray：整型数组原子类
AtomicReference
举例说明：
import java.util.concurrent.atomic.AtomicInteger;
public class Ch06 {
private static AtomicInteger adder = new AtomicInteger();
public static void main(String[] args) throws InterruptedException {
int a = 10;
for (int i = 0; i < 1000; i++) {
Thread thread = new Thread(() -> {
adder.getAndIncrement();
});
thread.start();
// 阻塞
thread.join();
}
System.out.println("a:" + a);
System.out.println("aaa：" + adder.get());
}
}
线程池
为什么要使用线程池
-
降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
-
提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
-
提过线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
JDK自带的四种线程池是通过Executors提供的。
- newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，创建新线程。
- newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。
- newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行
- newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有的任务按照指定顺序执行
这四种线程池的初始化都调用了同一个构造器：
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数的意义（重要）：
corePoolSize：线程池里线程的数量，核心线程池大小
maximumPoolSize：指定了线程池里的最大线程数量
keepAliveTime：当线程池线程数量大于corePoolSize，多出来的空闲线程，多长时间被销毁
unit：时间单位
workQueue：任务队列，用于存放提交但是尚未被执行的任务
threadFactory：线程工厂，用来创建线程，线程工厂就是我们new线程的
handler：拒绝策略，是将任务添加到线程池中时，线程池拒绝该任务所采取的相应的措施。常见的工作队列
ArrayBlockingQueue：基于数组的有界阻塞队列。FIFO。
LinkedBlockingQueue：基于链表的有界阻塞队列。FIFO
线程池提供了四种拒绝策略：
AbortPolicy：直接抛出异常，默认的策略。
CallerRunPolicy：用调用者所在的线程来执行任务
DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务
DiscardPolicy：直接丢弃任务
举例说明
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class Ch01 {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
Runnable taskOne = () -> {
System.out.println(Thread.currentThread().getName() + "taskOne...");
};
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
ExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 40; i++) {
fixedThreadPool.submit(taskOne);
}
}
}
-
线下车企门店如何实现线上线下融合？12-23
-
鸿蒙Next ArkTS编程规范总结12-23
-
物流团队冬至高效运转，哪款办公软件可助力风险评估？12-23
-
优化库存，提升效率：医药企业如何借助看板软件实现仓库智能化12-23
-
项目管理零负担！轻量化看板工具如何助力团队协作12-23
-
电商活动复盘，为何是团队成长的核心环节？12-23
-
鸿蒙Next ArkTS高性能编程实战12-23
-
数据驱动：电商复盘从基础到进阶！12-23
-
从数据到客户：跨境电商如何通过销售跟踪工具提升营销精准度？12-23
-
汽车4S店运营效率提升的核心工具12-23
-
ERP 系统开发案例：用 PERT 图打造高效项目管理12-23
-
初创团队必备！全面解析支持甘特图的项目管理工具与功能特点12-23
-
任务进度跟踪不再难！可视化项目协作工具精选12-23
-
看板工具为汽车销售门店协作赋能：关键方法12-23
-
0.96寸OLED显示屏详解12-23
