20220804 刘世琦 学习记录

Java

  • 1. LockSupport工具类

    • 1.1 LockSupport是什么

    • 1.2 LockSupport方法介绍

    • 1.3 park和wait、notify的区别

  • 2. Lock锁

    • 2.1 Lock的形式

    • 2.2 Lock是一个接口

    • 2.3 synchronized和Lock的区别

    • 2.4 Lock锁的原理cas和aqs

  • 3. JUC并发编程包

    • 3.1 原子类Atomic
  • 4. 线程池

    • 4.1 为什么要使用线程池

    • 4.2 JDK自带的四种线程池

    • 4.3 参数的意义(重要):

    • 4.4 常见的工作队列

    • 4.5 线程池提供了四种拒绝策略:

    • 4.6 线程池的五种状态:

    • 4.7 自定义线程:

    • 4.8 创建线程的4种方式:

今日例题

1. LockSupport工具类

1.1 LockSupport是什么

1.2 LockSupport方法介绍

阻塞线程

1.void park():阻塞当前线程,如果调用unpark方法或者当前线程被中断,从能从park()方法中返回;

如下代码:

public class LockSupportTest {
    public static void main(String[] args) {
        System.out.println("开始park");
        LockSupport.park();
        System.out.println("结束park");
    }
}

2.void park(Object blocker):功能同方法1,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;

如下代码:

 public static void park(Object blocker) {
        //获取调用线程
        Thread t = Thread.currentThread();
        //设置该线程的blocker变量
        setBlocker(t, blocker);
        //挂起线程
        UNSAFE.park(false, 0L);
        //线程被激活后清除blocker变量,因为一般都是在线程阻塞时才分析原因
        setBlocker(t, null);
    }

3.void parkNanos(long nanos):阻塞当前线程,最长不超过nanos纳秒,增加了超时返回的特性;

4.void parkNanos(Object blocker, long nanos):功能同方法3,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;

5.void parkUntil(long deadline):阻塞当前线程,知道deadline;

6.void parkUntil(Object blocker, long deadline):功能同方法5,入参增加一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查;

唤醒线程

void unpark(Thread thread):唤醒处于阻塞状态的指定线程
如下代码:

public class LockSupportTest {
    public static void main(String[] args) {
        System.out.println("开始park");
        LockSupport.unpark(Thread.currentThread());
        //调用park方法
        LockSupport.park();
        System.out.println("结束park");
    }
}

park和unpark如下代码:

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("子线程开始park");
            LockSupport.park();//调用park,挂起自己
            System.out.println("子线程结束park");
        });
        //启动子线程
        thread.start();
        //主线程休眠1s
        Thread.sleep(1000);
        System.out.println("主线程开始unPark");
        //调用unpark方法,让thread线程持有许可证,然后子线程的park方法返回
        LockSupport.unpark(thread);
    }
}

1.3 park和wait、notify的区别

区别:

1、park不需要获取某个对象的锁
2、因为中断park不会抛出InterruptedException异常,需要在park之后自行判断中断状态,然后做额外处理

总结:

1、park和unpark可以实现wait和notify的功能,但是并不和wait和notify交叉使用
2、park和unpark不会出现死锁
3、blocker的作用可以看到阻塞对象的信息

2. Lock锁

2.1 Lock的形式:

Lock lock = new ReentrantLock();
lock.lock();
try{
//正常处理业务逻辑
}catch(Exceotion e){
//当出现异常的解决方案
}finally{//释放资源,关闭链接,关闭输入输出流
//手动释放锁
lock.unlock();
}

2.2 Lock是一个接口

方法:

//获取锁
void lock(); 
//获取锁的过程能够响应中断
void lockInterruptibly() throws InterruptedException;
//非阻塞式响应中断能立即返回,获取锁放回true反之返回fasle
boolean tryLock();
//超时获取锁,在超时内或者未中断的情况下能够获取锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//获取与lock绑定的等待通知组件,当前线程必须获得了锁才能进行等待,进行等待时会先释放锁,当再次获取锁时才能从等待中返回
Condition newCondition();
// 释放锁。
unlock();

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

ReentrantLock重入锁,是实现Lock接口的一个类,也是在实际编程中使用频率很高的一个锁,支持重入性,表示能够对共享资源能够重复加锁,即当前线程获取该锁再次获取不会被阻塞。

  • 2.3 synchronized和Lock的区别

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

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

ReentrantReadWriteLock:

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

2.4 Lock锁的原理cas和aqs

3. JUC并发编程包

3.1 原子类Atomic

原子更新基本类型
atomic包原子基本类型的工具类,主要有这些:

AtomicBoolean:以原子更新的方式更新boolean;
AtomicInteger:以原子更新的方式更新Integer;
AtomicLong:以原子更新的方式更新Long;

这几个类的用法基本一致,这里以AtomicInteger为例总结常用的方法

addAndGet(int delta) :以原子方式将输入的数值与实例中原本的值相加,并返回最后的结果;
incrementAndGet() :以原子的方式将实例中的原值进行加1操作,并返回最终相加后的结果;
getAndSet(int newValue):将实例中的值更新为新值,并返回旧值;
getAndIncrement():以原子的方式将实例中的原值加1,返回的是自增前的旧值;

原子数组类型
atomic原子数组中元素的类有:

AtomicIntegerArray:原子更新整型数组中的元素;
AtomicLongArray:原子更新长整型数组中的元素;
AtomicReferenceArray:原子更新引用类型数组中的元素

这几个类的用法一致,就以AtomicIntegerArray来总结下常用的方法:

addAndGet(int i, int delta):以原子更新的方式将数组中索引为i的元素与输入值相加;
getAndIncrement(int i):以原子更新的方式将数组中索引为i的元素自增加1;
compareAndSet(int i, int expect, int update):将数组中索引为i的位置的元素进行更新

原子更新引用类型
如果需要原子引用类型变量的话,为了保证线程安全,atomic也提供了相关的类:

AtomicReference:原子更新引用类型;
AtomicReferenceFieldUpdater:原子更新引用类型里的字段;
AtomicMarkableReference:原子更新带有标记位的引用类型;

4. 线程池

4.1 为什么要使用线程池

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

方法:

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) 

4.2JDK自带的四种线程池通过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)

4.3 参数的意义(重要):

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

4.4 常见的工作队列

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

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

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

4.6 线程池的五种状态:

RUNNING

状态说明:线程池处在RUNNING状态时,能够接收新任务,以及对已添加的任务进行处理。
状态切换:线程池的初始化状态是RUNNING。线程池被一旦被创建,就处于RUNNING状态,并且线程池中的任务数为0。

SHUTDOWN

状态说明:线程池处在SHUTDOWN状态时,不接收新任务,但能处理已添加的任务。
状态切换:调用线程池的shutdown()接口时,线程池由RUNNING -> SHUTDOWN。

STOP

状态说明:线程池处在STOP状态时,不接收新任务,不处理已添加的任务,并且会中断正在处理的任务。
状态切换:调用线程池的shutdownNow()接口时,线程池由(RUNNING or SHUTDOWN ) -> STOP。

TIDYING

状态说明:当所有的任务已终止,ctl记录的”任务数量”为0,线程池会变为TIDYING状态。当线程池变为TIDYING状态时,会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的,若用户想在线程池变为TIDYING时,进行相应的处理;可以通过重载terminated()函数来实现。
状态切换:当线程池在SHUTDOWN状态下,阻塞队列为空并且线程池中执行的任务也为空时,就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下,线程池中执行的任务为空时,就会由STOP -> TIDYING。

TERMINATED

状态说明:线程池彻底终止,就变成TERMINATED状态。
状态切换:线程池处在TIDYING状态时,执行完terminated()之后,就会由 TIDYING -> TERMINATED。

4.7自定义线程:

/**
 * 自定义线程池
 *
 */
public class Ch02 {

    private static final AtomicInteger poolNumber = new AtomicInteger(1);

    private final ThreadGroup group;

    private final AtomicInteger threadNumber = new AtomicInteger(1);

    private final String namePrefix;

    Ch02(String name){
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();

        namePrefix = name + "-" + poolNumber.getAndIncrement() + "-thread-";
    }

    Ch02(){
        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) {
        Ch02 ch02 = new Ch02();
        ch02.newThread(()->{
            System.out.println("自定义线程池创建的线程...");
        }).start();
    }

}

4.8创建线程的4种方式:

1.直接初始化Thread类,实现Runnable接口
2.使用Callable和Future创建线程
3.使用线程池例如用Executor框架
4.继承Thread类创建线程

今日例题

1.两个线程轮流打印数字,从1-100,并起名字

public class Test01 {

    private static class MyNumberTest {

        private static boolean flag = true;

        // 要打印的数字
        private static int count = 0;

        public synchronized void print1() {
            for (int i = 0; i < 50; i++) {
                while (!flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }
        public synchronized void print2() {
            for (int i = 0; i < 50; i++) {
                while (flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }

    }

    public static void main(String[] args) {
        MyNumberTest myNumberTest = new MyNumberTest();
        Thread t1 = new Thread(() -> {
            myNumberTest.print1();
        });
        t1.setName("线程A");
        Thread t2 = new Thread(() -> {
            myNumberTest.print2();
        });
        t2.setName("线程B");

        t1.start();
        t2.start();
    }

}

2. 写两个线程,一个线程打印152,另一个线程打印AZ,打印顺序是12A 34B 56C 5152Z

public class Text3 {
    private static class MyNumberTest {

        private static boolean flag = true;
        private static char c = 64;

        public static void main(String[] args) {
                MyNumberTest myNumberTest = new MyNumberTest();
                Thread t1 = new Thread(() -> {
                    myNumberTest.print1();
                });
                t1.setName("线程A");
                Thread t2 = new Thread(() -> {
                    myNumberTest.print2();
                });
                t2.setName("线程B");

                t1.start();
                t2.start();
            }



        public synchronized void print1() {
            for (int i = 1; i < 53; i++) {
                while (!flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + i + ++i);
                flag = !flag;
                notifyAll();
            }
        }

        public synchronized void print2() {
            for (char i = 0; i < 26; i++) {
                while (flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + (char)(65+i)+" ");
                flag = !flag;
                notifyAll();
            }
        }
    }
}

3. 交替打印两个数组

class Two{
    int[] arr1 = new int[]{1,2,3,4,5};
    int[] arr2 = new int[]{-1,-2,-3,-4,-5};

    private static boolean flag = true;



    public synchronized void print1() {
        for (int i = 0; i < arr1.length; i++) {
            while (!flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "->" + arr1[i]);
            flag = !flag;
            notifyAll();
        }
    }
    public synchronized void print2() {
        for (int i = 0; i < arr2.length; i++) {
            while (flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "->" + arr2[i]);
            flag = !flag;
            notifyAll();
        }
    }


}
public class Test4 {
    public static void main(String[] args) {
        Two two = new Two();
        Thread t1 = new Thread(() -> {
            two.print1();
        });
        t1.setName("线程A");
        Thread t2 = new Thread(() -> {
            two.print2();
        });
        t2.setName("线程B");

        t1.start();
        t2.start();
    }
}

总结:
今天学习的状态很好,线程这部分课程知识点繁多复杂,需要反复思考理解,同时又复习了前两天学过的知识,进行整合,对于这部分学习,我的主要问题在于知识点的混淆记不清楚,我通过二次学习查阅资料并且询问老师同学,加强我对知识点的记忆以及区分,这是个“漫长的过程”,我会在练习以及复习中加强我的薄弱部分。在课堂练习中,每一题的逐步递进,让我写的越来越熟练,对于一些错误,也在思考中得到了解决。今天的收获非常大,心情很好,再接再厉!

posted @ 2022-08-04 18:35  刘世琦  阅读(47)  评论(0)    收藏  举报