2022-08-04 第四小组 王星苹 学习笔记

###学习心得###

还是关于线程方面的一些练习，有更多的参数，方法，还有线程池的一些功能，

还有比较了一下synchronized和ReentrantLock的区别：

Lock手动，Lock灵活。Lock是一个接口，synchronized是一个关键字。

###心情###

能开始举一反三，相同类型的题能改一改实现功能了

掌握程度：还行一般

练习与总结：👇👇👇👇👇

LockSupport工具类：

线程阻塞的工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞

阻塞之后也有唤醒的方法

park：停车，如果我们把Thread看成一辆车，park就是让车停下

unpark：就是让车启动然后跑起来

这里的park和unpark其实实现了wait和notify的功能

区别：

1.park不需要获取某个对象的锁

2.因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，然后做额外的处理。

 

总结：

1.park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用

2.park和unpark不会出现死锁

3.blocker的作用看到阻塞对象的信息

import java.util.concurrent.locks.LockSupport;


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锁：

Lock是一个接口

Lock接口的实现类ReentrantLock

ReentrantLock，可重入锁。

实现了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) {

    }
}

synchronized和ReentrantLock的区别：

1.Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的。

2.synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁

3.Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断。

4.Lock可以提高多个线程进行读操作的效率。

Lock手动，Lock灵活

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

并发编程的三大特性：

1.原子性：原子操作可以是一个步骤，也可以是多个步骤，但顺序不能乱，也不可以被切割只执行其中的一部分，将整个操作视为一个整体，原子性不仅仅是多行代码，也可能是多条指令。

2.可见性

3.有序性：synchronized lock：可以保证原子性，可见性，有序性。

CAS：compare and swap，比较并交换。JDK11改成了compare and set。

思路：给一个元素赋值的时候，先看看内存里的那个值到底变没变。

AQS：抽象队列同步器，用来解决线程同步执行的问题。

 

JUC并发编程包：

原子类Atomic	基本类型	AtomicInteger： 整型原子类	AtomicLong： 长整型原子类	AtomicBoolean： 布尔型原子类
	数组类型	AtomicLongArray： 长整型数组原子类	AtomicIntegerArray： 整型数组原子类	AtomicReference<V>： 引用数据类型原子类

 

线程池：

为什么使用线程池？

1.降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗

2.提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行

3.提高线程的可管理性，线程比较稀缺的资源，如果无限制的创建，不仅会小号系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，

调优和监控。

 

JDK自带的四种线程池通过Executors提供的。

1.newCachedThreadPool：创建一个可缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，创建新线程。

2.newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待

3.newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行

4.newSingleThreadExecutor：创建一个单线程的线性池，它只会用唯一的工作线程来执行任务保证所有的任务，按照指定顺序执行。

 

这四种线程池的初始化都调用了同一个构造器：

new ThreadPoolExecutor(int carePoolSize,

                                          int maximumPoolSize,

                                          loog keepAliveTime,

                                          TimeUnit unit,

                                          BlockingQueue<Runnable>workQueue,

                                          ThreadFactory threadFactory,

                                          RejectedExecutionHandler handler)

参数的意义（重要）：

1. carePoolSize：线程池里线程的数量，核心线程池的大小
2. maximumPoolSize：指定了线程池里的最大的线程数量。
3. keepAliveTime：当线程池线程数量大于carePoolSize，多出来的空闲线程，多长时间被销毁
4. unit：时间单位
5. workQueue：任务队列，用于存放提交但是尚未被执行的任务
6. threadFactory：线程工厂，用来创建线程，县城工厂就是我们的new线程
7. handler：拒绝策略，是将任务添加到先行池中，线程池拒绝该任务多采取的相应的措施

 

常见的工作队列;

1. ArrayBlockingQueue：基于数组的有界阻塞队列。FIFO。
2. LinkedBlockingQueue：基于链表的有界阻塞队列。FIFO。

 

线程池提供了四种拒绝策略：

1. AbortPolicy：直接抛出异常，默认的策略
2. CallerRunPolicy：用调用者所在的线程来执行任务
3. DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务
4. 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);
        }
 

自定义线程池：

import java.util.concurrent.atomic.AtomicInteger;


/**
 * 自定义线程池
 *
 */
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()
 

------------------------

------------------------