ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

2022-08-04 高严 学习笔记

2022-08-04 20:33:23  阅读：124  来源： 互联网

标签：Thread 04 lock 08 park 高严 线程 new public


一、今日重点

  • park与unpark
  • lock与unlock
  • JUC并发编程包
  • 线程池

二、进程概况

【√代表掌握了，-代表产生困惑但已解决，×代表没解决】
  • park与unpark【√】
  • 线程中断与唤醒【√】
  • （park和unpark）与（wait和notify）的区别【-】
  • park和unpark的总结【√】
  • Lock锁【√】
  • Lock接口的实现类ReentrantLock【√】
  • synchronized和Lock的区别【√】
  • JUC并发编程包【-】
  • 练习1（售票）【√】
  • 线程池【√】
  • 四种拒绝策略【√】
  • 自定义线程池【√】
  • 练习2（交替打印1-100）【√】
  • 练习3（打印12A、34B、56C...）【√】
  • 练习4（交替打印数组）【√】

三、今日知识

  • LockSupport工具类

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

  • park：停车。如果我们把Thread看成一辆车的话，park就是让车停下
  • unpark：就是让车启动然后跑起来
  • 阻塞
    LockSupport.park();
  • 线程中断
    t1.interrupt();
  • 唤醒线程2
    LockSupport.unpark(t2);
  • （park和unpark）与（wait和notify）的区别

1.park不需要获取某个对象的锁（不释放锁）

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

  • 总结：

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

2.park和unpark不会出现死锁。

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

  • lock锁：lock是一个接口
  • lock获得锁
  • unlock释放锁
  • trylock只在调用时获得锁
// 加锁
        lock.lock();
        try {
            // 正常处理业务逻辑
            // 输入输出的操作IO操作
            // 操作的是物理内存
            // 多线程是内存操作
            System.out.println();
        }catch (Exception e){
            // 当出现异常的解决方案
        }finally { // 释放资源，关闭连接，关闭输入输出流
            // 手动释放锁
            lock.unlock();
        }

// 如果拿到了锁
        if(lock.tryLock()){
            try {
                // 正常处理业务逻辑
            }catch (Exception e){
                // 当出现异常的解决方案
            }finally { // 释放资源，关闭连接，关闭输入输出流
                // 手动释放锁
                lock.unlock();
            }
        }else {
            // 如果没有拿到锁，则直接做另外的事情
        }
  • Lock接口的实现类ReentrantLock
  • ReentrantLock，可重入锁。
  • 实现了Lock接口
  • synchronized和Lock的区别：
  • 1.Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的。
  • 2.synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁。
  • 3.Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
  • 4.Lock可以提高多个线程进行读操作的效率。
  • Lock以下功能是synchronized不具备的
    ReentrantReadWriteLock：

对于一个应用而言，一般情况下读操作远远多于写的操作，如果仅仅是读的操作没有写的操作，
数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程写，写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。

在某些场景下能极大的提升效率。

 // 创建了一个读锁
            ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
            readLock.lock();

 // 创建了一个写锁
            ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
            writeLock.lock();
  • lock锁的原理cas和aqs
  • synchronized是由C语言实现的，只能作为关键字来使用
  • java提供了一些并发的编程的包，底层的实现原理cas和aqs
  • 并发编程三大特性：
  • 1.原子性：
  • 原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，**
  • 也不可以被切割只执行其中的一部分，将整个操作视为一个整体。**
  • 原子性不仅仅是多行代码，也可能是多条指令**。
  • 2.可见性
  • 3.有序性
  • synchronized lock：可以保证原子性、可见性、有序性。
  • CAS：

compare and swap，比较并交换。JDK11改成了compare and set。
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。

  • AQS：

抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表

  • JUC并发编程包
  • 1.原子类Atomic
  • 基本类型
  • AtomicInteger：整型原子类
  • AtomicLong：长整型原子类
  • AtomicBoolean：布尔型原子类
  • 数组类型
  • AtomicLongArray：长整型数组原子类
  • AtomicIntegerArray：整型数组原子类
  • AtomicReference：引用数据类型原子类
  • 线程池:为什么要使用线程池

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

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

（3）提过线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

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

1.newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，创建新线程。
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
2.newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
3.newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行
ExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
4.newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有的任务按照指定顺序执行
ExecutorService singleThreadExecutor = Executors.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：直接丢弃任务
  • 1.创建线程的4种方式
  • 2.线程同步（synchronized,ReentrantLock,ReentrantReadWriteLock）
  • 3.线程之间的通信（wait，notify，notifyAll）
  • 4.线程类的常用方法

四、练习汇总

  • 练习（售票）
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 + "张！");
                    count--;
                    // count = count - 1;
                }
            }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();
    }
}
  • 练习：两个线程轮流打印数字，从1-100
public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number,"线程一");
        Thread t2 = new Thread(number,"线程二");
        t1.start();
        t2.start();
    }
}

class Number implements Runnable{

    private int i = 0;

    @Override
    public void run() {
        while (true){
            synchronized (this) {
                notify();
                if(i < 100){
                    i++;
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }else{
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • 练习写两个线程，一个线程打印152，另一个线程打印AZ，打印顺序是12A 34B 56C ... 5152Z
class Print{
    private int flag = 0;
    private int count = 1;
    public synchronized void printNumber(){
        while (flag != 0){
            try {
                wait();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(2*count-1);
        System.out.println(2*count);
        flag = 1;
        notify();
    }
    public synchronized void printChar(){
        while (flag != 1){
            try {
                wait();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println((char)(count-1 + 'A'));
        count++;
        flag = 0;
        notify();
    }
}

public class Test2 {
    public static void main(String[] args) {
        Print print = new Print();
        new Thread(()->{
            for(int i = 0;i<26;i++){
                print.printNumber();
            }
        }).start();
        new Thread(()->{
            for(int i = 0;i<26;i++){
                print.printChar();
            }
        }).start();
    }
}
  • 练习：交替打印数组
class print{
    int[] arr1 = new int[]{1,2,3,4,5,6,7};
    int[] arr2 = new int[]{7,6,5,4,3,2,1};
    private int flag = 0;

    public synchronized void printNum1(){
        for (int i = 0; i < arr1.length; i++) {
            while (flag != 0){
                try {
                    wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(arr1[i]);
            flag = 1;
            notify();
        }
    }

    public synchronized void printNum2(){
        for (int i = 0; i < arr2.length; i++) {
            while (flag != 1){
                try {
                    wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(arr2[i]);
            flag = 0;
            notify();
        }
    }
}


public class Test3 {
    public static void main(String[] args) {
        Print print = new Print();
        Thread t1 = new Thread(() -> {
            print.printNum1();
        });
        Thread t2 = new Thread(() -> {
            print.printNum2();
        });
        t1.start();
        t2.start();
    }
}

五、学习总结

1、今天学习的内容有点多，park与unpark，lock与unlock，trylock，内容相对来说并没有极其难，只不过需要多多练习。
2、（park和unpark）与（wait和notify）的区别这里产生了困惑，但仔细读了几遍还是能够理解的。
3、明天再接再厉，希望作业可以顺利克服！

标签：Thread,04,lock,08,park,高严,线程,new,public
来源： https://www.cnblogs.com/ayannini/p/16552222.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有