首页 > 其他分享> 文章详细

2022-8-4 第一小组甘源册学习笔记

2022-08-04 21:31:25 阅读：232 来源： 互联网

标签：synchronized Thread 甘源册 Lock 笔记线程 2022 println new

知识点掌握情况
学习心情
1.多线程
2.线程池
注意事项
必须掌握

知识点掌握情况

Lock锁（了解）LockSupport工具类（了解）线程池（了解）

学习心情

迷茫，痛苦，懵逼！！！

1.多线程

1.1LockSupoprt工具类

线程阻塞的工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也可以进行唤醒。
- park方法：如果把Thread看成一辆车，park方法就是让车停下来。——wait方法
- unpark方法：unpark就是让车启动然后跑起来——notify方法
park与wait的区别
- park不需要获取某个对象的锁【不会释放同步锁】
- 因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，然后再做额外的处理

总结park和unpark

可以实现wait和notify的功能，但是并不和wait和notify交叉使用。
不会出现死锁

blocker的作用可以看到阻塞对象的信息

    Runnable runnable = () -> {
        synchronized (oj) {
            System.out.println(Thread.currentThread().getName());
            LockSupport.park("我被阻塞了");
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("被中断了....");
            }
            System.out.println("继续执行");
        }
    };
    Thread thread = new Thread(runnable, "线程一");
    thread.start();
    Thread.sleep(1000);
    System.out.println(LockSupport.getBlocker(thread));
    thread.interrupt();

1.2Lock锁（接口）

    lock.lock();
    // 如果拿到了锁
    if (lock.tryLock()) {
        try {
            // 正常处理业务逻辑
    
        } catch (Exception e) {
            // 当出现异常的解决方案
            e.printStackTrace();
        } finally { // 一般写释放资源,关闭连接,关闭输入输出流
            // 需要手动释放锁
            lock.unlock();
        }
    }else {
        // 如果没有拿到锁,直接做另外的事情
    
    }

Lock接口的实现类ReentrantLock

ReentrantLock可重入锁，实现类Lock接口

示例

package com.gyc.morning;


import java.util.concurrent.locks.ReentrantLock;
// 卖票
public class Ch03 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket("窗口一");
        Ticket ticket1 = new Ticket("窗口二");
        Ticket ticket2 = new Ticket("窗口三");
        new Thread(ticket).start();
        new Thread(ticket1).start();
        new Thread(ticket2).start();
    }
}

class Ticket implements Runnable {
    private static final ReentrantLock re = new ReentrantLock();
    private volatile static Integer count = 100;
    String name;

    public Ticket(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while (count > 0) {
            re.lock();
            try {
                if (count > 0) {
                    Thread.sleep(100);
                    System.out.println(name + "卖了一张票还剩:" + (--count));
                } else {
                    break;
                }
            }catch (InterruptedException  e){
                System.out.println("a");
            }catch (Exception e) {
                e.printStackTrace();
            } finally {
                re.unlock();
            }
        }
    }
}

Lock与synchronized的区别
1. Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的；
2. 发生异常时
  - synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。
  - Lock发生异常，若没有主动释放锁，极有可能占用资源不放手，需要在finally中手动释放锁。
3. Lock可以让等待锁的线程中断，使用synchronized只会等待的线程一直等待下去，不能响应线程中断
4. Lock可以提高多个线程进行读操作的效率
Lock以下功能synchronized不具备
1. ReentrantReadWriteLock（读写锁）
  - 对于一个应用而言，一般情况下读的操作远远多于写的操作。如果只有读没有写，数据又是线程安全的，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程在写，写是独占的，当有线程在执行写的操作是，其他线程既不能读也不能写。
Lock的原理cas和aqs
- CAS：compare and swap，比较并交换。JDK11改成了Compare and set。
  - 思路：就是一个元素赋值的时候，先看看内存里的那个值到底变没变。
- AQS：抽象队列（双向链表）同步器。用来解决线程同步执行的问题
并发编程的三大特性
- 原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，也不可以被切割只执行其中的一部分，将整个操作视为一个整体。原子性不仅仅是多行代码，也可能是多条指令。
- 可见性
- 有序性
synchronized Lock：可以保证原子性，可见性，有序性。

1.3 JUC并发编程包

原子类Atomic——供多线程使用

基本类型
- AtomicIntager：整型原子类
- AtomicLong：长整型原子类
- AtomicBoolean：布尔型原子类
数组类型
- AtomicLongAttay：长整型数组原子类
- AtomicIntagerArray：整型数组原子类

示例

    for (int i = 0; i < 1000; i++) {
        Thread thread = new Thread(()->{
            // 原子类相当于单线程,一次只能有一个线程对它进行操作
            adder.getAndIncrement();
        });
        thread.start();
        thread.join();
    }
    System.out.println(adder.get());

2.线程池

为什么要使用线程池
- 降低资源消耗,通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
- 提高线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源还会降低系统的稳定性，使用线程池可以进行统一分配，调优和监督。
JDK自带的四种线程池通过Executors提供的。
- newCachedThreadPool：创建一个可缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，创建新线程
- newFixedThreadPool：创建一个定长的线程池，可控制线程最大并发数，超出线程会在队列中等待。
- newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行
- newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定的顺序执行。
这四种线程池的初始化都调用了一个构造器（ThreadPoolExecutor）
- ```
ThreadPoolExecutor(int corePoolSize,    
                   int maximumPoolSize, 
                   long keepAliveTime,  
                   TimeUnit unit,  															   		BlockingQueue<Runnable> workQueue    
    			   ThreadFactory threadFactory, 
				   RejectedExecutionHandler handler) 
```
  - corePoolsize:线程池里线程的数量，核心线程池大小
  - maximumPoolsize:指定了线程池里的最大线程数量
  - threadFactory:线程工厂，用来创建线程，线程工厂就是我们new线程的
  - keepAliveTime:当线程池线程数量大于corePooLsize，多出来的空闲线程，多长时间被销毁
  - unit:时间单位
  - handLer:拒绝策略，是将任务添加到线程池中时，线程池拒绝该任务多采取的响应的措施。
  - workQueue:任务队列，用于存放提交但是尚未被执行的任务
常见的工作队列
- ArrayBlockingQueue：基于数组的有界阻塞队列
- LinkedBlockingQueue：基于链表的有界阻塞队列
线程池提供的四种拒绝策略
- AbortPolicy：直接抛出异常，默认的策略
- CallerRunPolicy：用调用者所在的线程来执行任务
- DiscardOldestPolicy：丢弃阻塞队列中最考前的任务，并执行当前任务
- DiscardPolicy：直接丢弃任务

注意事项

	// 输入(Scanner)输出(sout语句)操作是IO操作-操作的是物理内存
	// 多线程是内存操作
	System.out.println()；
    // 键盘输入，打印输出，极其消耗资源IO资源——在实际开发中绝对不允许使用，明令禁止

必须掌握

创建线程的四种方式【重要程度：5*】
线程同步（synchronized，ReentrantLock，ReentrantReadWriteLock）【重要程度：5*】
线程之间的通信（wait，notify，notifyAll）【重要程度：5*】
线程类的常用方法【重要程度：3*】
指令重排，线程争抢，可见性，原子性，volatile关键字

标签：synchronized,Thread,甘源册,Lock,笔记,线程,2022,println,new
来源： https://www.cnblogs.com/gycddd/p/16550068.html

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

ICode9

2022-8-4 第一小组 甘源册 学习笔记