2022-8-4 第七组 ptz 锁与线程池和工具类
LockSupport工具类
线程阻塞的工具类。，所有的方法都是静态方法，可以让线程在任意位置阻塞，
阻塞之后也有唤醒的方法。
park：停车。如果我们把Thread看成一辆车的话，park就是让车停下
unpark：就是让车启动然后跑起来
park和unpark其实实现了wait和notify的功能
区别：
1.park不需要获取某个对象的锁（不释放锁）
2.因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，
然后做额外的处理。
public class Ch01 {
public static final Object OBJ = new Object();
public void show() {
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
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();
Thread.sleep(1000);
System.out.println(LockSupport.getBlocker(t1));
t2.start();
Thread.sleep(3000);
// 线程中断
t1.interrupt();
// 把t2唤醒
LockSupport.unpark(t2);
t1.join();
t2.join();
}
}
Lock以下功能是synchronized不具备的！
ReentrantReadWriteLock：
对于一个应用而言，一般情况下读操作远远多于写的操作，如果仅仅是读的操作没有写的操作，
数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程写，
写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。
import java.util.concurrent.locks.ReentrantLock;
//卖票
public class Demo2 implements Runnable {
private static final ReentrantLock lock = new ReentrantLock();
private static Integer count =100;
String name ;
public Demo2(String name) {
this.name = name;
}
@Override
public void run() {
while (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();
}
}
}
}
class Pz{
public static void main(String[] args) {
Demo2 d1 = new Demo2("窗口一");
Demo2 d2 = new Demo2("窗口二");
Demo2 d3 = new Demo2("窗口三");
new Thread(d1).start();
new Thread(d2).start();
new Thread(d3).start();
}
}
读锁与写锁
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
并发编程三大特性：
* 1.原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，
也不可以被切割只执行其中的一部分，将整个操作视为一个整体。
原子性不仅仅是多行代码，也可能是多条指令。
* 2.可见性
* 3.有序性
synchronized lock：可以保证原子性、可见性、有序性。
CAS：compare and swap，比较并交换。JDK11改成了compare and set。
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS：抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表
键盘输入
-
打印输出
-
极其耗资源IO操作。这两种在实际开发中绝对不允许使用
-
java.util.concurrent.atomic下JUC并发编程包
1.原子类Atomic -
基本类型
-
AtomicInteger：整型原子类
-
AtomicLong：长整型原子类
-
AtomicBoolean：布尔型原子类
-
数组类型
-
AtomicLongArray：长整型数组原子类
-
AtomicIntegerArray：整型数组原子类
-
AtomicReference
：引用数据类型原子类
-
线程池
- 为什么要使用线程池
- （1）降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
- （2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
- （3）提过线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，
-
还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
JDK自带的四种线程池通过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)
参数的意义（重要）：
* corePoolSize：线程池里线程的数量，核心线程池大小
* maximumPoolSize：指定了线程池里的最大线程数量
* keepAliveTime：当线程池线程数量大于corePoolSize，多出来的空闲线程，多长时间被销毁
* unit：时间单位
* workQueue：任务队列，用于存放提交但是尚未被执行的任务
* threadFactory：线程工厂，用来创建线程，线程工厂就是我们new线程的
* handler：拒绝策略，是将任务添加到线程池中时，线程池拒绝该任务多采取的相应的措施。
常见的工作队列
* ArrayBlockingQueue：基于数组的有界阻塞队列。FIFO。
* LinkedBlockingQueue：基于链表的有界阻塞队列。FIFO
线程池提供了四种拒绝策略：
* AbortPolicy：直接抛出异常，默认的策略。
* CallerRunPolicy：用调用者所在的线程来执行任务
* DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务
* DiscardPolicy：直接丢弃任务
自定义线程池
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();
}
}
总结：
1.park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用。
2.park和unpark不会出现死锁。
3.blocker的作用看到阻塞对象的信息
重要
1.创建线程的4种方式*****
2.线程同步（synchronized,ReentrantLock,ReentrantReadWriteLock）*****
3.线程之间的通信（wait，notify，notifyAll）*****
4.线程类的常用方法***
指令重排，线程争抢，可见性，原子性，volatile关键字
本文来自博客园，作者：阿萨德菩提子，转载请注明原文链接：https://www.cnblogs.com/ychptz/p/16552221.html
