20220804 刘世琦 学习记录
Java
-
1. LockSupport工具类
-
1.1 LockSupport是什么
-
1.2 LockSupport方法介绍
-
1.3 park和wait、notify的区别
-
-
2. Lock锁
-
2.1 Lock的形式
-
2.2 Lock是一个接口
-
2.3 synchronized和Lock的区别
-
2.4 Lock锁的原理cas和aqs
-
-
3. JUC并发编程包
- 3.1 原子类Atomic
-
4. 线程池
-
4.1 为什么要使用线程池
-
4.2 JDK自带的四种线程池
-
4.3 参数的意义(重要):
-
4.4 常见的工作队列
-
4.5 线程池提供了四种拒绝策略:
-
4.6 线程池的五种状态:
-
4.7 自定义线程:
-
4.8 创建线程的4种方式:
-
今日例题
1. LockSupport工具类
1.1 LockSupport是什么
1.2 LockSupport方法介绍
阻塞线程
1.void park():阻塞当前线程,如果调用unpark方法或者当前线程被中断,从能从park()方法中返回;
如下代码:
public class LockSupportTest {
public static void main(String[] args) {
System.out.println("开始park");
LockSupport.park();
System.out.println("结束park");
}
}
2.void park(Object blocker):功能同方法1,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;
如下代码:
public static void park(Object blocker) {
//获取调用线程
Thread t = Thread.currentThread();
//设置该线程的blocker变量
setBlocker(t, blocker);
//挂起线程
UNSAFE.park(false, 0L);
//线程被激活后清除blocker变量,因为一般都是在线程阻塞时才分析原因
setBlocker(t, null);
}
3.void parkNanos(long nanos):阻塞当前线程,最长不超过nanos纳秒,增加了超时返回的特性;
4.void parkNanos(Object blocker, long nanos):功能同方法3,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;
5.void parkUntil(long deadline):阻塞当前线程,知道deadline;
6.void parkUntil(Object blocker, long deadline):功能同方法5,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;
唤醒线程
void unpark(Thread thread):唤醒处于阻塞状态的指定线程
如下代码:
public class LockSupportTest {
public static void main(String[] args) {
System.out.println("开始park");
LockSupport.unpark(Thread.currentThread());
//调用park方法
LockSupport.park();
System.out.println("结束park");
}
}
park和unpark如下代码:
public class LockSupportTest {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
System.out.println("子线程开始park");
LockSupport.park();//调用park,挂起自己
System.out.println("子线程结束park");
});
//启动子线程
thread.start();
//主线程休眠1s
Thread.sleep(1000);
System.out.println("主线程开始unPark");
//调用unpark方法,让thread线程持有许可证,然后子线程的park方法返回
LockSupport.unpark(thread);
}
}
1.3 park和wait、notify的区别
区别:
1、park不需要获取某个对象的锁
2、因为中断park不会抛出InterruptedException异常,需要在park之后自行判断中断状态,然后做额外处理
总结:
1、park和unpark可以实现wait和notify的功能,但是并不和wait和notify交叉使用
2、park和unpark不会出现死锁
3、blocker的作用可以看到阻塞对象的信息
2. Lock锁
2.1 Lock的形式:
Lock lock = new ReentrantLock();
lock.lock();
try{
//正常处理业务逻辑
}catch(Exceotion e){
//当出现异常的解决方案
}finally{//释放资源,关闭链接,关闭输入输出流
//手动释放锁
lock.unlock();
}
2.2 Lock是一个接口
方法:
//获取锁
void lock();
//获取锁的过程能够响应中断
void lockInterruptibly() throws InterruptedException;
//非阻塞式响应中断能立即返回,获取锁放回true反之返回fasle
boolean tryLock();
//超时获取锁,在超时内或者未中断的情况下能够获取锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//获取与lock绑定的等待通知组件,当前线程必须获得了锁才能进行等待,进行等待时会先释放锁,当再次获取锁时才能从等待中返回
Condition newCondition();
// 释放锁。
unlock();
Lock接口的实现类ReentrantLock:可重入锁
ReentrantLock重入锁,是实现Lock接口的一个类,也是在实际编程中使用频率很高的一个锁,支持重入性,表示能够对共享资源能够重复加锁,即当前线程获取该锁再次获取不会被阻塞。
- 2.3 synchronized和Lock的区别
synchronized和Lock的区别:
1、Lock是一个接口,synchronized是一个关键字,是由底层(C)语言实现的。
2、synchronized发生异常时,会自动释放线程占用的锁不会发生死锁,Lock发生异常,若没有主动释放,极有可能占用资源不放手,需要在finally中手动释放锁。
3、Lock可以让等待锁的线程响应中断,使用synchronized只会让等待的线程一直等待下去,不能响应中断。
4、Lock可以提高多个线程进行读操作的效率。
Lock以下功能是synchronized不具备的!
ReentrantReadWriteLock:
1.对于一个应用而言,一般情况下读操作远远多于写的操作,如果仅仅是读的操作没有写的操作,
2.数据又是线程安全,读写锁给我们提供了一种锁,读的时候可以很多线程一起读,但是不能有线程写,
3.写是独占的,当有线程在执行写的操作,其他线程既不能读,也不能写。
4.在某些场景下能极大的提升效率
2.4 Lock锁的原理cas和aqs
3. JUC并发编程包
3.1 原子类Atomic
原子更新基本类型
atomic包原子基本类型的工具类,主要有这些:
AtomicBoolean:以原子更新的方式更新boolean;
AtomicInteger:以原子更新的方式更新Integer;
AtomicLong:以原子更新的方式更新Long;
这几个类的用法基本一致,这里以AtomicInteger为例总结常用的方法
addAndGet(int delta) :以原子方式将输入的数值与实例中原本的值相加,并返回最后的结果;
incrementAndGet() :以原子的方式将实例中的原值进行加1操作,并返回最终相加后的结果;
getAndSet(int newValue):将实例中的值更新为新值,并返回旧值;
getAndIncrement():以原子的方式将实例中的原值加1,返回的是自增前的旧值;
原子数组类型
atomic原子数组中元素的类有:
AtomicIntegerArray:原子更新整型数组中的元素;
AtomicLongArray:原子更新长整型数组中的元素;
AtomicReferenceArray:原子更新引用类型数组中的元素
这几个类的用法一致,就以AtomicIntegerArray来总结下常用的方法:
addAndGet(int i, int delta):以原子更新的方式将数组中索引为i的元素与输入值相加;
getAndIncrement(int i):以原子更新的方式将数组中索引为i的元素自增加1;
compareAndSet(int i, int expect, int update):将数组中索引为i的位置的元素进行更新
原子更新引用类型
如果需要原子引用类型变量的话,为了保证线程安全,atomic也提供了相关的类:
AtomicReference:原子更新引用类型;
AtomicReferenceFieldUpdater:原子更新引用类型里的字段;
AtomicMarkableReference:原子更新带有标记位的引用类型;
4. 线程池
4.1 为什么要使用线程池
1、为了降低资源的消耗,通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
2、提高响应速度。当任务到达时,任务可以不需要等到线程创建就能执行
3、提高线程的可管理性,线程比较稀缺的资源,如果无限制的创建,不仅会消耗系统资源,还有降低系统的稳定性,使用线程池可以进行统一的分配、调优和监控
方法:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
4.2JDK自带的四种线程池通过Executors提供的。
1.newCachedThreadPool:创建一个可缓存线程池,如果线程池长度超过处理需要,可以灵活回收空闲线程,
若无可回收,创建新线程。
2.newFixedThreadPool:创建一个定长的线程池,可以控制线程最大并发数,超出的线程会在队列中等待。
3.newScheduledThreadPool:创建一个定长的线程池,支持定时及周期性任务执行
4.newSingleThreadExecutor:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有的任务按照指定顺序执行
这四种线程池的初始化都调用了同一个构造器:
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
4.3 参数的意义(重要):
corePoolSize:线程池里线程的数量,核心线程池大小
maximumPoolSize:指定了线程池里的最大线程数量
keepAliveTime:当线程池线程数量大于corePoolSize,多出来的空闲线程,多长时间被销毁
unit:时间单位
workQueue:任务队列,用于存放提交但是尚未被执行的任务
threadFactory:线程工厂,用来创建线程,线程工厂就是我们new线程的
handler:拒绝策略,是将任务添加到线程池中时,线程池拒绝该任务多采取的相应的措施。
4.4 常见的工作队列
ArrayBlockingQueue:基于数组的有界阻塞队列。FIFO。
LinkedBlockingQueue:基于链表的有界阻塞队列。FIFO
4.5 线程池提供了四种拒绝策略:
AbortPolicy:直接抛出异常,默认的策略。
CallerRunPolicy:用调用者所在的线程来执行任务
DiscardOldestPolicy:丢弃阻塞队列中最靠前的任务,并执行当前任务
DiscardPolicy:直接丢弃任务
4.6 线程池的五种状态:
RUNNING
状态说明:线程池处在RUNNING状态时,能够接收新任务,以及对已添加的任务进行处理。
状态切换:线程池的初始化状态是RUNNING。线程池被一旦被创建,就处于RUNNING状态,并且线程池中的任务数为0。
SHUTDOWN
状态说明:线程池处在SHUTDOWN状态时,不接收新任务,但能处理已添加的任务。
状态切换:调用线程池的shutdown()接口时,线程池由RUNNING -> SHUTDOWN。
STOP
状态说明:线程池处在STOP状态时,不接收新任务,不处理已添加的任务,并且会中断正在处理的任务。
状态切换:调用线程池的shutdownNow()接口时,线程池由(RUNNING or SHUTDOWN ) -> STOP。
TIDYING
状态说明:当所有的任务已终止,ctl记录的”任务数量”为0,线程池会变为TIDYING状态。当线程池变为TIDYING状态时,会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的,若用户想在线程池变为TIDYING时,进行相应的处理;可以通过重载terminated()函数来实现。
状态切换:当线程池在SHUTDOWN状态下,阻塞队列为空并且线程池中执行的任务也为空时,就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下,线程池中执行的任务为空时,就会由STOP -> TIDYING。
TERMINATED
状态说明:线程池彻底终止,就变成TERMINATED状态。
状态切换:线程池处在TIDYING状态时,执行完terminated()之后,就会由 TIDYING -> TERMINATED。
4.7自定义线程:
/**
* 自定义线程池
*
*/
public class Ch02 {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
Ch02(String name){
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = name + "-" + poolNumber.getAndIncrement() + "-thread-";
}
Ch02(){
this("default");
}
public Thread newThread(Runnable r){
// 就是在创建线程
Thread t = new Thread(group,r,namePrefix + threadNumber.getAndIncrement(),0);
if(t.isDaemon()){
t.setDaemon(false);
}
if(t.getPriority() != Thread.NORM_PRIORITY){
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
public static void main(String[] args) {
Ch02 ch02 = new Ch02();
ch02.newThread(()->{
System.out.println("自定义线程池创建的线程...");
}).start();
}
}
4.8创建线程的4种方式:
1.直接初始化Thread类,实现Runnable接口
2.使用Callable和Future创建线程
3.使用线程池例如用Executor框架
4.继承Thread类创建线程
今日例题
1.两个线程轮流打印数字,从1-100,并起名字
public class Test01 {
private static class MyNumberTest {
private static boolean flag = true;
// 要打印的数字
private static int count = 0;
public synchronized void print1() {
for (int i = 0; i < 50; i++) {
while (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + ++count);
flag = !flag;
notifyAll();
}
}
public synchronized void print2() {
for (int i = 0; i < 50; i++) {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + ++count);
flag = !flag;
notifyAll();
}
}
}
public static void main(String[] args) {
MyNumberTest myNumberTest = new MyNumberTest();
Thread t1 = new Thread(() -> {
myNumberTest.print1();
});
t1.setName("线程A");
Thread t2 = new Thread(() -> {
myNumberTest.print2();
});
t2.setName("线程B");
t1.start();
t2.start();
}
}
2. 写两个线程,一个线程打印152,另一个线程打印AZ,打印顺序是12A 34B 56C 5152Z
public class Text3 {
private static class MyNumberTest {
private static boolean flag = true;
private static char c = 64;
public static void main(String[] args) {
MyNumberTest myNumberTest = new MyNumberTest();
Thread t1 = new Thread(() -> {
myNumberTest.print1();
});
t1.setName("线程A");
Thread t2 = new Thread(() -> {
myNumberTest.print2();
});
t2.setName("线程B");
t1.start();
t2.start();
}
public synchronized void print1() {
for (int i = 1; i < 53; i++) {
while (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + i + ++i);
flag = !flag;
notifyAll();
}
}
public synchronized void print2() {
for (char i = 0; i < 26; i++) {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + (char)(65+i)+" ");
flag = !flag;
notifyAll();
}
}
}
}
3. 交替打印两个数组
class Two{
int[] arr1 = new int[]{1,2,3,4,5};
int[] arr2 = new int[]{-1,-2,-3,-4,-5};
private static boolean flag = true;
public synchronized void print1() {
for (int i = 0; i < arr1.length; i++) {
while (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + arr1[i]);
flag = !flag;
notifyAll();
}
}
public synchronized void print2() {
for (int i = 0; i < arr2.length; i++) {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "->" + arr2[i]);
flag = !flag;
notifyAll();
}
}
}
public class Test4 {
public static void main(String[] args) {
Two two = new Two();
Thread t1 = new Thread(() -> {
two.print1();
});
t1.setName("线程A");
Thread t2 = new Thread(() -> {
two.print2();
});
t2.setName("线程B");
t1.start();
t2.start();
}
}
总结:
今天学习的状态很好,线程这部分课程知识点繁多复杂,需要反复思考理解,同时又复习了前两天学过的知识,进行整合,对于这部分学习,我的主要问题在于知识点的混淆记不清楚,我通过二次学习查阅资料并且询问老师同学,加强我对知识点的记忆以及区分,这是个“漫长的过程”,我会在练习以及复习中加强我的薄弱部分。在课堂练习中,每一题的逐步递进,让我写的越来越熟练,对于一些错误,也在思考中得到了解决。今天的收获非常大,心情很好,再接再厉!