2022-08-04 第五组张明敏学习笔记

最新推荐文章于 2024-08-06 19:03:47 发布

小张同学的小张

最新推荐文章于 2024-08-06 19:03:47 发布

阅读量111

点赞数

分类专栏： Java 多线程文章标签：学习

本文链接：https://blog.csdn.net/qq_50392643/article/details/126165578

版权

Java 同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

多线程

3 篇文章 0 订阅

订阅专栏

线程同步(synchronized, ReentrantLock , ReentrantReadwriteLock )*****

线程之间的通信(wait，notify ,notifyAll )*****

线程类的常用方法***

指令重排，线程争抢，可见性，原子性，volatile关键字

三、案例

1.两个线程轮流打印数字，从1-100：

2. 轮流打印1-52，A-Z，效果 12A....

3.轮流打印两个数组

一、LockSupport工具类

线程阻塞的工具类。所有方法都是静态的，可以让线程在任意位置阻塞
阻塞之后也有唤醒的方法。
park：停下。（停车）
unpark：启动。

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

区别：
1.park不需要获取某个对象的锁
2.因为中断park不会抛出InstantException异常，需要park之后自行判断中断状态，
然后做额外处理。

总结:
1.park和unpark 可以实现wait和notify的功能，但是并不和wait和notify交叉使用。
2.park和unpark不会出现死锁。
3.btocker的作用看到阻塞对象的信息

 public static final Object OBJ=new Object();

    public void show(){
        try {
            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,"1:");
        Thread t2=new Thread(runnable,"2");
        t1.start();
        Thread.sleep(1000);
        //获取LockSupport.park“我被阻塞了”的信息
        System.out.println(LockSupport.getBlocker(t1));
        t2.start();
        Thread.sleep(3000);
        //线程中断
        t1.interrupt();
        //把t2唤醒
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }

1. Lock锁

Lock是一个接口

键盘输入
打印输出
开发中不允许使用

  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操作
            //操作是物理内存
            //多线程是内存处理
        }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 {
                //正常处理业务逻辑
                //输入输出的操作 IO操作
                //操作是物理内存
                //多线程是内存处理
            }catch (Exception e){
                //当出现异常的解决方案
            }finally {//释放资源，关闭连接，关闭输入输出流
                //手动释放所
                lock.unlock();
            }
        }else {
            //
        }
    }

    public static void main(String[] args) {


    }

Lock接口的实现类ReentrantLockReentrantLock,可重入锁。
实现了Lock接口

synchronized和Lock的区别:
1.Lock是一个接口，synchronized是一个关键字，是由底层(C）语言实现的。
2.synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。
Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁。
3.Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
4.Lock可以提高多个线程进行读操作的效率。

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

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

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

lock锁的原理cas和aqs

synchronized是由C语言实现的，只能作为关键字来使用
java提供了一些并发的编程的包，底层的实现原理cas和aqs

并发编程三大特性:
1.原子性:原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，
也不可以被切割只执行其中的一部分，将整个操作视为一个整体。
原子性不仅仅是多行代码，也可能是多条指令。
2.可见性
3.有序性

synchronized lock:可以保证原子性、可见性、有序性。

CAS: compare and swap, 比较并交换。JDK11改成了compare and set.
思路:就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS:抽象队列同步器，用来解决线程同步执行的问题。它是-个双向链表

java. util. concurrent. atomic下
JUC并发编程包

1.原子类Atomic

基本类型：

AtomicInteger:整型原子类
Atomiclong:长整型原子类
AtomicBoolean:布尔型原子类

数组类型：

AtomicLongArray:长整型数组原类
AtomicIntegerArray:整型数组原子类

二、线程池

1、为什么要使用线程池

(1）降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
(2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
(3）提过线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

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

1.newCachedThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程;
若无可回收，创建新线程。
2.newFixedThreadPool:创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。
3.newScheduledThreadPool:创建一个定长的线程池，支持定时及周期性任务执行
4.newSingLeThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证
所有的任务按照指定顺序执行

这四种线程池的初始化都调用了同一个构造器:
ThreadPooLExecutor(int corePoolSize,
                   int maximumPoolSize,
                   long keepAliveTime,
                   Timeunit unit,
                   BLockingQueue<Runnable> workQueue,
                   ThreadFactory threadFactory,
                   RejectedExecutionHandLer handLer)