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

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

Java 多线程 Lock

学习重点

1.Lock锁
2.线程池

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

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

Java 多线程 Lock

学习重点

1.Lock锁
2.线程池

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