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. 写两个线程，一个线程打印1_{52，另一个线程打印A}Z，打印顺序是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) 收藏举报

刷新页面返回顶部

20220804 刘世琦学习记录

Java

1. LockSupport工具类

2. Lock锁

3. JUC并发编程包

4. 线程池

今日例题

1. LockSupport工具类

1.1 LockSupport是什么

1.2 LockSupport方法介绍

`阻塞线程`

`唤醒线程`

1.3 park和wait、notify的区别

区别：

总结：

2. Lock锁

2.1 Lock的形式：

2.2 Lock是一个接口

2.4 Lock锁的原理cas和aqs

3. JUC并发编程包

3.1 原子类Atomic

4. 线程池

4.1 为什么要使用线程池

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

4.3 参数的意义（重要）：

4.4 常见的工作队列

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

4.6 线程池的五种状态：

4.7自定义线程：

4.8创建线程的4种方式：

今日例题

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

2. 写两个线程，一个线程打印1_{52，另一个线程打印A}Z，打印顺序是12A 34B 56C 5152Z

3. 交替打印两个数组

公告

20220804 刘世琦 学习记录

Java

1. LockSupport工具类

2. Lock锁

3. JUC并发编程包

4. 线程池

今日例题

1. LockSupport工具类

1.1 LockSupport是什么

1.2 LockSupport方法介绍

阻塞线程

唤醒线程

1.3 park和wait、notify的区别

区别：

总结：

2. Lock锁

2.1 Lock的形式：

2.2 Lock是一个接口

2.4 Lock锁的原理cas和aqs

3. JUC并发编程包

3.1 原子类Atomic

4. 线程池

4.1 为什么要使用线程池

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

4.3 参数的意义（重要）：

4.4 常见的工作队列

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

4.6 线程池的五种状态：

4.7自定义线程：

4.8创建线程的4种方式：

今日例题

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

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

3. 交替打印两个数组

公告

20220804 刘世琦学习记录

`阻塞线程`

`唤醒线程`

2. 写两个线程，一个线程打印1_{52，另一个线程打印A}Z，打印顺序是12A 34B 56C 5152Z