2022-08-04 学习日记（24th day）多线程--第三天

激进的土豆

已于 2022-08-25 21:27:46 修改

阅读量97

点赞数 1

分类专栏： java学习日记文章标签：学习 java

于 2022-08-04 19:31:53 首次发布

本文链接：https://blog.csdn.net/weixin_49627122/article/details/126165058

版权

java学习日记专栏收录该内容

48 篇文章 2 订阅

订阅专栏

LockSupport工具类

Lock锁

Lock接口的实现类：ReentrantLock-----可重入锁

synchronized和Lock的区别：

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

LockSupport工具类

线程阻塞的工具类。所有的方法都是静态方法，可以让线程在任意位置阻塞
阻塞之后也有唤醒的方法
park:停车。如果我们把Thread看成一辆车的话，park就是让车停下
unpark:就是让车启动然后跑起来

这里的park和unpark其实实现类wait和notify的功能，但还是由区别的

区别是：

1.park不需要获取某个对象的锁（不释放锁）
2.因为中断park不会抛出异常，需要在park之后自行判断中断状态。然后做额外的处理。。
3.可以传参数，可以在被阻塞时，传递信息：LockSupport.park("我被阻塞啦").

public class Test01 {
    public static final Object OBJ = new Object();

    public void show(){
        try {
            super.wait();
        } catch (InterruptedException e) {//线程终端异常
            throw new RuntimeException(e);
        }
    }

    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, "线程一");
        Thread t2 = new Thread(runnable, "线程二");
        t1.start();
        Thread.sleep(1000);
        System.out.println(LockSupport.getBlocker(t1));
        t2.start();
        Thread.sleep(3000);
        t1.interrupt();//线程中断
        LockSupport.unpark(t2);//唤醒线程二
        t1.join();
        t1.join();
    }
}

运行结果：

总结：

1.park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用
2.park和unpark不会出现死锁。他会一直拿在手里
3.blocker的作用可以看到阻塞的对象的信息。

Lock锁

Lock是一个接口

先创建一个Lock对象：Lock lock = new Lock(){},里面需要重写所有抽象方法，但是太多了，在这里我就省略了，都用lock标识符代替。

正常使用方式：

//如果拿到了锁0
        if (lock.tryLock()) {
            try {
                //正常处理业务逻辑
                //输入输出的操作IO操作
                //操作的是物理内存
                //多线程是内存操作
            } catch (Exception e) {
                //当出现异常的解决方案
            } finally {//释放资源，关闭连接，关闭输入输出流。
                //手动释放锁
                lock.unlock();
            }
        }else {
            //如果没有拿到锁，则直接做另外的事情
        }

Lock接口的实现类：ReentrantLock-----可重入锁

public class Test03 {
    public static void main(String[] args) {
        Thread one = new Thread(new Ticket("一号窗口"));
        Thread two = new Thread(new Ticket("ER号窗口"));
        one.start();
        two.start();
    }
}

class Ticket implements Runnable{
    private static final ReentrantLock LOCK=new ReentrantLock();

    private static Integer count=100;
    private 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) {
                    e.printStackTrace();
                }
                if (count > 0) {
                    System.out.println(name + "出票一张" + Ticket.count + "张");
                    count--;
                }
            }finally {
                LOCK.unlock();
            }
        }
    }
}

synchronized和Lock的区别：

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

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

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

实例：

public class Test04 {

    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(200);
                System.out.println("我在读数据" + count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
            }
        };
        Runnable write = () -> {
            ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
            writeLock.lock();
            try {
                Thread.sleep(200);
                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,"read").start();
            }else {
                new Thread(write,"write").start();
            }
        }
    }


}

Lock锁的原理cas和aqs

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

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

并发编程的三大特征：

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

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

JUC并发编程包

在java.util.concurrent.atomic下

1.原子类：Atomic
        AtomicInteger:整型原子类
        AtomicLong:长整型原子类
        AtomicBoolean:布尔型原子类
2.数组类型:
        AtomicLongArray:长整型数组原子类
        AtomicIntegerArray：整型数组原子类
        AtomicReference<V>：引用数据类型原子类

举个整型的例子，输出是1000个，原理就是一个一个输出，不是一起执行，抢资源了。

public class Test06 {

    private static AtomicInteger adder = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            Thread thread=new Thread(()->{
                adder.getAndIncrement();
            });
            thread.start();
            thread.join();
        }
        System.out.println(adder.get());
    }
}

线程池：

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

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

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

这四个用法都一样，我们就拿一个举例子：

public class Test01 {
    public static void main(String[] args) {
//        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
//        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
//        ExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(10);
//        ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();
        Runnable t=()->{
            System.out.println(Thread.currentThread().getName()+"t...");
        };
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        for (int i = 0; i <40 ; i++) {
            fixedThreadPool.submit(t);
        }

    }

}

这四种线程池的初始化，都调用了同一个构造器：

ThreadPoolExecutor(int corePoolSize, 线程池里的线程数量，核心线程池大小
                                  int maximumPoolSize, 指定了线程池里的取入线程数量
    long keepAliveTime, 当前线程池线程数量大于corePoolSize，多出来的空闲线程，多长时间被销毁
TimeUnit unit, 时间单位
BlockingQueue<Runnable> workQueue, 任务队列，用于存放提交但是尚未被执行的任务
ThreadFactory threadFactory, 线程工厂，用来创建线程，线程工厂就是我们new线程的
                RejectedExecutionHandler handler) 拒绝策略，是将任务添加到线程池中时，线程吃拒绝该任务多采取的相应的措施。

常见的工作队列

ArrayBlockingQueue:基于数组的有界阻塞队列。FIFO。
LinkedBlockingQueue:基于链表的有界阻塞队列。FIFO。

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

AbortPolicy,直接抛出异常，默认的策略。
CallerRunPolicy:用调用者所在的线程来执行任务
DiscardOldestPolicy:丢弃阻塞队列中最靠前的任务，并执行当前任务
DiscardPolicy:直接丢弃任务

自定义线程池：

public class Test02 {
    private static final AtomicInteger poolNumber=new AtomicInteger();


    private final ThreadGroup group;
    private final AtomicInteger threadNumber= new AtomicInteger();
    private final String namePrefix;
    Test02(String name){
        SecurityManager s=System.getSecurityManager();
        group=(s !=null)?s.getThreadGroup():Thread.currentThread().getThreadGroup();
        namePrefix = name + "-" +poolNumber.getAndIncrement()+"-thread-";
    }
    Test02(){
        this("default");
    }
    public Thread newThread(Runnable r){
        Thread t = new Thread(group,r,namePrefix+threadNumber.getAndIncrement(),0);
        if(t.isDaemon()){
            t.setDaemon(false);
        }
        if(t.getPriority() != Thread.NORM_PRIORITY){
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }

    public static void main(String[] args) {
        Test02 t=new Test02();
        t.newThread(()->{
            System.out.println("runnable接口，自定义线程池创建的线程");
        }).start();
    }
}

线程池执行任务过程：