高并发基础知识

最新推荐文章于 2024-08-13 16:15:07 发布

天星阳

最新推荐文章于 2024-08-13 16:15:07 发布

阅读量929

点赞数 19

文章标签：后端

本文链接：https://blog.csdn.net/qq_37840702/article/details/134967238

版权

五、线程池：ThreadPoolExcuter

六、JUC 三大辅助类

6.1、CountDownLatch: 减少计数

6.2、CyclicBarrier: 循环栅栏

6.3、Semaphore: 信号灯

一、线程状态及转换

1、New(初始化状态)

2、Runnable(就绪状态)

3、Running(运行状态)

4、Blocked(阻塞状态)

5、Terminated（终止状态）

二、线程安全

2.1、如何保证现在安全？

   原子性：指一个操作是不可分割的、完整的，要么全部执行成功，要么全部不执行，不存在执行一半的情况
   可见性：一个线程读数据修改了，其他线程立刻可见
   有序性：代码从上往下一次执行。不会出现上面的代码还没执行，就执行下面的代码（指令重排）

2.2、为什么会出现线程不安全的情况？

多个线程同时操作同一个共享资源。可能出现业务安全问题。如下案例

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                for (int j = 0; j <100 ; j++) {
                    list.add("1");
                }
            }).start();
        }

        //休眠100毫秒确保 t1,t2线程都执行完毕
        Thread.sleep(1000);

        System.out.println(list.size());
    }

正常情况下list大小为10000，因为存在线程不安全的问题，输出的list大小始终小于10000

2.3、如何保证线程安全？

使用线程锁synchronized或lock锁，对上面案例进行改造如下：

public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        Object obj = new Object();

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                for (int j = 0; j <100 ; j++) {
                    synchronized (obj){
                        list.add("1");
                    }
                }
            }).start();
        }

        //休眠100毫秒确保 t1,t2线程都执行完毕
        Thread.sleep(1000);

        System.out.println(list.size());
    }

三、线程锁

3.1、Synchronized

修饰一个代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；

修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

修饰一个静态的方法：其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

修饰一个类：其作用的范围是 synchronized 后面括号括起来的部分，作用主的对象是这个类的所有对象。

3.2、Lock

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

ReentrantLock：可重入锁

ReentrantReadWriteLock：读写锁

案例如下

public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock(); //注意这个地方

        List<String> list = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                for (int j = 0; j <100 ; j++) {
                    try {
                        lock.lock();
                        list.add("1");
                    } catch (Exception e) {

                    }finally {
                        lock.unlock();
                    }
                }
            }).start();
        }

        //休眠100毫秒确保 t1,t2线程都执行完毕
        Thread.sleep(1000);

        System.out.println(list.size());
    }

四、创建线程的3种方式

4.1、Thread

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println("线程：" + Thread.currentThread().getName());
            }).start();
        }
    }

4.2、Runable接口

定义一个类实现Runnable接口，并重写run()方法，该run()方法的方法体代表了该线程需要完成的任务。把run()方法称为线程执行体

public class MyRunnable implements Runnable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable, "A线程").start();
        new Thread(myRunnable, "B线程").start();
    }

    @Override
    public void run() {
        System.out.println("线程名：" + Thread.currentThread().getName());
    }
}

4.3、Callable接口

创建Callable接口的实现类，并实现call()方法，该call()方法作为线程的执行体，且该call()方法有返回值；

public class MyCallable implements Callable<Integer> {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(myCallable);
        new Thread(task).start();
        System.out.println("子线程的返回值："+task.get());
    }

    @Override
    public Integer call() {
        System.out.println("线程名：" + Thread.currentThread().getName());
        return 1;
    }
}

五、线程池：ThreadPoolExcuter

7个参数说明：

corePoolSize：线程池的核心线程数
maximumPoolSize：能容纳的最大线程数
keepAliveTime：空闲线程存活时间
unit：存活的时间单位
workQueue：存放提交但未执行任务的队列
threadFactory：创建线程的工厂类
handler：等待队列满后的拒绝策略

案例如下：

public class demo {
    // 创建一个线程池
    public static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 最大线程数
            60, // 线程空闲时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(10000), // 任务队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
    );

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            executor.execute(() -> {
                System.out.println("线程名：" + Thread.currentThread().getName());
            });
        }
    }
    
}

六、JUC 三大辅助类

6.1、CountDownLatch: 减少计数

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

案例如下：6个同学全部离开才能关门

    /**
     *  6 个同学陆续离开教室后值班同学才可以关门
     */
    public static void main(String[] args) throws Exception{
        //定义一个数值为 6 的计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //创建 6 个同学
        for (int i = 1; i <= 6; i++) {
            new Thread(() ->{
                try{
                    if(Thread.currentThread().getName().equals("同学 6")){
                        Thread.sleep(2000);
                    }
                    System.out.println(Thread.currentThread().getName() + "离开了");
                    //计数器减一,不会阻塞
                    countDownLatch.countDown();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }, "同学" + i).start();
        }
        //主线程 await 休息
        System.out.println("主线程睡觉");
        countDownLatch.await();
        //全部离开后自动唤醒主线程
        System.out.println("全部离开了,现在的计数器为" + countDownLatch.getCount());
    }

6.2、CyclicBarrier: 循环栅栏

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中 CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作。

案例如下：集齐7颗龙珠就可以召唤神龙

public class demo {

    //定义神龙召唤需要的龙珠总数
    private final static int NUMBER = 7;
    /**
     * 集齐 7 颗龙珠就可以召唤神龙
     * @param args
     */
    public static void main(String[] args) {
        //定义循环栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () ->{
            System.out.println("集齐" + NUMBER + "颗龙珠,现在召唤神龙!!!!!!!!!");
        });
        //定义 7 个线程分别去收集龙珠
        for (int i = 1; i <= 7; i++) {
            new Thread(()->{
                try {
                    if(Thread.currentThread().getName().equals("龙珠 3 号")){
                        System.out.println("龙珠 3 号抢夺战开始,孙悟空开启超级赛亚人模式!");
                        Thread.sleep(5000);
                        System.out.println("龙珠 3 号抢夺战结束,孙悟空打赢了,拿到了龙珠 3 号!");
                    }else{
                        System.out.println(Thread.currentThread().getName() + "收集到 了!!!!");
                    }
                    cyclicBarrier.await();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }, "龙珠" + i + "号").start();
        }
    }
    
}

6.3、Semaphore: 信号灯

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可。

案例如下：抢车位, 6 部汽车 3 个停车位

    /**
     * 抢车位, 10 部汽车 1 个停车位
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //定义 3 个停车位
        Semaphore semaphore = new Semaphore(3);
        //模拟 6 辆汽车停车
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(100);
            //停车
            new Thread(() ->{
                try {
                    System.out.println(Thread.currentThread().getName() + "找车位 ing");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "汽车停车成功!");
                    Thread.sleep(10000);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName() + "溜了溜了");
                    semaphore.release();
                }
            }, "汽车" + i).start();
        }
    }

天星阳

关注

19
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
高并发基础知识

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中 CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。修饰一个代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
复制链接

扫一扫