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);
        }
    }
}

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/278956.html

2022-08-04 第五组罗大禹学习笔记

20220801 第五小组罗大禹学习笔记

Java 多线程 Lock

学习重点

学习内容

Java 多线程 Lock

LockSupport工具类

区别：

总结：

举例说明：

Lock锁

synchronized和Lock的区别：

举例：

Lock接口的实现类ReentrantLock

举例说明：

Lock以下功能是synchronized不具备的！

ReentrantReadWriteLock：

举例说明：

Lock锁的原理cas和aqs

并发编程三大特性：

JUC并发编程包

1.原子类Atomic

线程池

为什么要使用线程池

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

参数的意义（重要）：

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

举例说明

发表回复

2022-08-04 第五组 罗大禹 学习笔记

20220801 第五小组 罗大禹 学习笔记

Java 多线程 Lock

学习重点

学习内容

Java 多线程 Lock

LockSupport工具类

区别：

总结：

举例说明：

Lock锁

synchronized和Lock的区别：

举例：

Lock接口的实现类ReentrantLock

举例说明：

Lock以下功能是synchronized不具备的！

ReentrantReadWriteLock：

举例说明：

Lock锁的原理cas和aqs

并发编程三大特性：

JUC并发编程包

1.原子类Atomic

线程池

为什么要使用线程池

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

参数的意义（重要）：

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

举例说明

相关推荐

发表回复

2022-08-04 第五组罗大禹学习笔记

20220801 第五小组罗大禹学习笔记