多线程三 并发容器简单使用

已于 2023-03-05 22:54:30 修改
阅读量283 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程 队列 queue java
于 2020-04-06 17:26:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/105343177
版权

目录

1.threadLocal

2.ArrayList、Vector、CopyOnWriteArrayList

 3.map相关并发容器

4.ConcurrentLinkedQueue

5.BlockingQueue提供的方法

5.1ArrayBlockingQueue

5.2LinkedBlockingQeque 

5.3DelayQueue

5.4LinkedTransferQueue 

5.5 PriorityBlockingQueue 

5.6 SynchronousQueue 

总结：

1.threadLocal

本地线程变量，在每个线程会独立开辟内存空间。

在高并发先谨慎使用；

注意：在使用后调用`

local.remove();

`方法移除变量

private static ThreadLocal local = new ThreadLocal();

public static void main(String[] args) {
    new Thread(()->{
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        local.set("A");
        System.out.println(Thread.currentThread().getName()+" "+local.get());
    },"线程 1").start();
    new Thread(()->{
        local.set("B");
        System.out.println(Thread.currentThread().getName()+" "+local.get());
    },"线程 2").start();
    System.out.println("main "+local.get());
// 移除线程变量
   local.remove();
}

2.ArrayList、Vector、CopyOnWriteArrayList

这里三个容器，ArrayList、vector和CopyOnwriteArrayList

从测试结果中可以看出：ArrayList不是线程安全，会进行很多重复的操作，致使在所有线程运行完后，大小达不到10000，而Vector是线程安全的，不会出现重复读，重复写的问题，而copyOnWriterArrayList呢，是读快，写慢，因为他写的时候要进行复制，大大拉低了效率；

 public static void main(String[] args) {
//        List<String> list1 = new ArrayList<>();// 耗时：12  大小：9754
//        Vector<String> list1 = new Vector<>(); // 耗时：10 大小：10000
        List<String> list1 = new CopyOnWriteArrayList<>(); // 写耗时：75 写大小：10000 读耗时：22
        Thread[] threads = new Thread[100];

        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            threads[i] =  new Thread(()->{
                for (int j = 0; j < 100; j++) {
                    int i1 = r.nextInt(10000);
                    list1.add("A"+i1);
                    ;
                }
            });
        }
        long time = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("大小 "+list1.size());
        System.out.println("耗时："+(end - time));

        Thread[] threads2 = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threads2[i] = new Thread(()->{
                for (int j = 0; j < 10000; j++) {
                    list1.get(j);
                }
            });
        }
        long time2 = System.currentTimeMillis();
        for (Thread thread : threads2) {
            thread.start();
        }
        for (Thread thread : threads2) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("耗时："+(System.currentTimeMillis() - time2));
    }

Collections提供了一个方法synchronizedList可以将非线程安全的容器转换为线程安全的容器，看它的实现就是在方法上加了一个synchronized关键字，但是使用iterator的时候就不行了，因为他调用的还是List本身的迭代器，没有做同步处理，所以在这种情况下要手动上锁；注意：我们常使用的增加for也是利用了迭代器。

List<String> list = new ArrayList<>();
List<String> strings = Collections.synchronizedList(list);

Synchronized 和Vecotr最主要的区别：

  1. vector扩容为原来的2倍长度，ArrayList扩容为原来的1.5倍

  2. synchronized有很好的扩展和兼容功能，它可以将所有的list的子类转成线程安全的类

  3. 使用synchronizedList的时候，进行遍历需要手动进行同步处理

  4. synchronizedlist可以指定锁定的对象

 3.map相关并发容器

public static void main(String[] args) {
//    Map<String, String> map = new ConcurrentHashMap<>(); // 302
//        Map<String, String> map = new ConcurrentSkipListMap<>(); // 358
//    Map<String, String> map = new Hashtable<>(); // 400

      Map<String, String> m = new HashMap<>();
      Map<String, String> map = Collections.synchronizedMap(m); // 465

        Random random = new Random();
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);
        long start = System.currentTimeMillis();
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for(int j=0; j<10000;j++) {
                    map.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
//             map1.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
                }
                latch.countDown();
            });
        }
        Arrays.asList(threads).forEach(t->t.start());
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }

hashMap

hashTable

concurrentHashMap

key/value = null可以存储null键，nullvalue

key和value都不能存储

key和value都不能存储

初始容量

16

11

16

线程安全

否

是

是

效率

高

< concurrentHashMap

>hashTable

ConcurrentSkipListMap 和上面不同，他的实现方式不一样，且key是有序的，支持更高的并发，存取是是log(N)，和线程数无关，线程越多越能体现出优势。

4.ConcurrentLinkedQueue

模拟场景：1000张票，10个售票窗口

public class ThreadContainer2 {

    private static List<Integer> list = new ArrayList<Integer>();
    private Integer tickets = 100;

    public synchronized void sall(){
        if (tickets > 0) {
            list.add(tickets--);
            System.out.println(Thread.currentThread().getName()+" sall "+tickets);
        }
    }

    public Integer getTicket(){
        return tickets;
    }

    public static void main(String[] args) {
        ThreadContainer2 t = new ThreadContainer2();

        System.out.println("开始售票。。。");
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                while (true) {
                        try {
                            TimeUnit.SECONDS.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        t.sall();
                    }
            },"售票口 "+(i+1)).start();
        }
    }
}

使用ConcurrentLinkedQueue来实现看看：

private static Queue<Integer> list = new ConcurrentLinkedQueue<Integer>();

static{
    for (int i = 0; i < 1000; i++) {
        list.add(i);
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            while (true) {
                // 这个方法是线程安全的
                Integer poll = list.poll();
                if (poll == null) {
                    break;
                }
                // 就算多个线程都同时来到这里，因为上一个代码是线程安全的，所以就算来到这，也是空
                System.out.println(Thread.currentThread().getName()+" ticket "+poll);
            }
        }," 售票口 "+i).start();
    }
}

代码简化了，没有之前的那种复杂

这个容器比较有用的方法：

ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue();

for (int i = 0; i < 10; i++) {
    queue.add("a"+i);
}
System.out.println("容器"+queue.size());
System.out.println("poll取值："+queue.poll());
System.out.println("poll 取值后的容器"+queue.size());
System.out.println("peek取值："+queue.peek());
System.out.println("peek取值后的容量："+queue.size());

这个容器多用于生产者和消费者问题

offer(e) // 队列可以放入，则返回true，不能返回false

poll()  // 取不到数据，返回null，取到的对象会被丢弃

peek()  //和poll一样，但是取出的对象不会被丢弃

add()  // 底层调用offer，不会抛出异常

5.BlockingQueue提供的方法

抛异常

特定值

阻塞

超时

插入

add(E e)

offer(E e)

put(E e)

offer(E e, long timeout, TimeUnit unit) 

移除

remove(Object o)

E poll()

take()

poll(long timeout, TimeUnit unit)

offer(E e);       // 队列可以放入，则返回true，不能返回false

offer(E e, long timeout, TimeUnit unit)     // 指定时间内，还不能放入就返回false

E poll()     // 取不到数据，返回null，取到的对象会被丢弃

poll(long timeout, TimeUnit unit)     // 指定时间内，能取到数据就取队头，没有则返回异常

E peek()    // 和poll一样，但是取出的对象不会被丢弃

5.1ArrayBlockingQueue

基于数组的有界队列，创建后无法改变容量

public static void main(String[] args) throws InterruptedException {
   BlockingQueue<String> strings = new ArrayBlockingQueue<>(10);
   for (int i = 0; i < 10; i++) {
      strings.put("a" + i);
   }
   strings.add("aaaa");
   strings.offer("aaaa",1, TimeUnit.SECONDS);
   System.out.println(strings);
}

5.2LinkedBlockingQeque 

无界，最大长度为Integer.MAX_VALUE

public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        Thread[] threads = new Thread[1];
        Thread[] threads2 = new Thread[10];

        for (int i = 0; i < 1; i++) {
            threads[i] = new Thread(()->{
//                while (true) {
                    for (int j = 0; j < 100; j++) {
                        try {
                            queue.put(j);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
//                }
            },"线程 "+i);
        }

        for (int i = 0; i < 10; i++) {
            threads2[i] = new Thread(()->{
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName()+" 获取 "+queue.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        Arrays.asList(threads).forEach(a->a.start());
        Arrays.asList(threads2).forEach(a->a.start());
    }

5.3DelayQueue

队列中的元素需要实现Delayed接口，实现排序和延时的定义

public class ThreadContainer11 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<MyQ> queue = new DelayQueue<>();
        long start = System.currentTimeMillis();
        MyQ m1 = new MyQ(start+1000,"延迟1秒");
        MyQ m2 = new MyQ(start+2000,"延迟2秒");
        MyQ m3 = new MyQ(start+3000,"延迟3秒");
        MyQ m4 = new MyQ(start+4000,"延迟4秒");
        MyQ m5 = new MyQ(start+5000,"延迟5秒");
        queue.put(m1);
        queue.put(m2);
        queue.put(m3);
        queue.put(m4);
        queue.put(m5);

        for (int i = 0; i < 5; i++) {
            System.out.println(queue.take().getName());
        }
    }

    static class MyQ implements Delayed {
        long time ;
        String name;
        public MyQ(long time,String name){
            this.time = time;
            this.name = name;
        }
        // 定义剩余到期时间
        @Override
        public long getDelay(TimeUnit unit) {
            return time - System.currentTimeMillis();
        }

        // 定义排序规则
        @Override
        public int compareTo(Delayed o) {
            if (this.getDelay(TimeUnit.MICROSECONDS) < o.getDelay(TimeUnit.MICROSECONDS)) {
                return 1;
            }else if(this.getDelay(TimeUnit.MICROSECONDS) > o.getDelay(TimeUnit.MICROSECONDS)){
                return -1;
            }else {
                return 0;
            }
        }
        public String getName(){
            return name;
        }
    }
}

5.4LinkedTransferQueue 

比其他队列多一个transfer ;使用transfer 的方式例如有多个消费者，和一个生产者，当存在消费者的情况下，他会将对象给消费者，不会放到队列里，再让消费取，比较快

public static void main(String[] args) throws InterruptedException {
    LinkedTransferQueue<String> queue = new LinkedTransferQueue<>();

    Thread t1 = new Thread(()->{
        try {
            System.out.println("线程1 "+queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread t2 = new Thread(()->{
        try {
            System.out.println("线程2 "+queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    t1.start();
    t2.start();
    
    queue.transfer("aaaaaa");
    System.out.println(queue.size());
}

5.5 PriorityBlockingQueue 

这个队列，会对放入的对象进行优先级排序，而优先级排序是有compareTo方法定义的，必须实现接口Comparable，但是他的排序只会将排序后的第一个放到队列第一个，其他仍是乱的

public class ThreadContainer8 implements Comparable {

    private Integer i;

    public ThreadContainer8(){}

    public ThreadContainer8(Integer i) {
        this.i = i;
    }

    @Override
    public int compareTo(Object o) {
        return i - ((ThreadContainer8) o).getI();
    }

    public Integer getI() {
        return i;
    }

    public static void main(String[] args) {
        PriorityBlockingQueue<ThreadContainer8> q = new PriorityBlockingQueue();
        Random r = new Random();
        Thread[] threads = new Thread[10];

      for (int i = 0; i < 10; i++) {
          threads[i] = new Thread(()->{
              for (int j = 0; j < 10; j++) {
                  q.put(new ThreadContainer8(r.nextInt(100)));
              }
          });
      }
        Arrays.asList(threads).forEach(t->t.start());
        Arrays.asList(threads).forEach(t->
                {
                    try {
                        t.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
        );
        q.forEach(e-> System.out.print(e.getI()+" "));
        System.out.println();
        System.out.println("s="+q.peek().getI());
    }
}

5.6 SynchronousQueue 

同步队列；容量为1，放入一个就要消费掉，不要用add

public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 报queue full异常
//        for (int i = 0; i < 5; i++) {
//            queue.add(i);
//        }
        System.out.println(queue.size());

        Thread t1 = new Thread(()->{
            try {
                System.out.println("线程1 "+queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(()->{
            try {
                System.out.println("线程2 "+queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        for (int i = 0; i < 2; i++) {
            queue.put(i);
        }
    }

总结：

名称

类名

说明

List相关并发容器

CopyOnWriteArrayList

读快写慢；写前复制，写完替换

Map/Set相关并发容器

ConcurrentHashMap

key和value都不能存储null，初始容量16

ConcurrentSkipListMap

key和value都不能存储null；key有序；它的存取时间log(N)

队列相关容器

ConcurrentLinkedQeque

FIFO（先入先出）；cas实现

ConcurrentLinkedDueue

与ConcurrentLinkedQeque不同的是支持双向操作

ArrayBlockingQueue

有界队列，固定容量，不支持空元素

DelayQueue

提供过期时间功能；队列头是最接近过期的元素，没有过期元素则会取出null

LinkedBlockingQeque

无界队列，最大是Integer.MAX_VALUE；添加删除不是互斥的

LinkedBlockingDueue

双向阻塞队列

LinkedTransferQueue

比其他队列多transfer方法，这个方法是会将元素给一个正在等待的消费者，不会放入队列，没有消费者则等待

PriorityBlockingQueue

放入对象必须实现Comparable接口，按compareTo实现方法，将优先级高的放在第一个，其他对象无序

SynchronousQueue

容量为1，即时消费，提供了put的阻塞方法，底层使用transfer 

用针戳左手中指指头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线程池
cLover_xiaolei的博客
03-12 230
下面将从线程的设计思路及线程池的使用进行说明。线程池管理主体设计思路是：1、封装线程管理对象 MyThread，用于线程创建、线程开启、线程睡眠、任务绑定等操作。2、封装空闲线程栈管理对象IdleThreadContainer，用于空闲线程栈的维护管理等操作。空闲的线程放于此栈中。3、封装忙碌线程队列管理对象BusyThreadContainer，用于忙碌线程队列的维护及管理等操作。忙碌的线程放于...
【2018最新最详细】并发多线程教程
11-15
【2018最新最详细】并发多线程教程，课程结构如下 1.并发编程的优缺点 2.线程的状态转换以及基本操作 3.java内存模型以及happens-before规则 4.彻底理解synchronized 5.彻底理解volatile 6.你以为你真的了解final吗...
Java多线程编程中的两种常用并发容器讲解
09-03
主要介绍了Java多线程编程中的两种常用并发容器讲解,分别是ConcurrentHashMap与ConcurrentHashMap,需要的朋友可以参考下
【Java并发编程】6.常见并发容器
01-21
多线程环境下Java提供的一些简单容器都无法使用了要用到JUC中的大部分容器，由于ConcurrentHashMap是高频考点用到也不较多因此着重写了下，其余的容器就先Mark下。奥利给 跳表 简而言之跳表就是多层链表的结合体，跳表分为许多层(level)，每一层都可以看作是数据的索引，这些索引的意义就是加快跳表查找数据速度。每一层的数据都是有序的，上一层数据是下一层数据的子集，并且第一层(level 1)包含了全部的数据；层次越高，跳跃性越大，包含的数据越少。并且随便插入一个数据该数据是否会是跳表索引完全随机的跟玩骰子一样，redis中的zset底层就是跳表数据结构。并且跳表的速度几乎接近红
七大排序算法
热门推荐
yahid的博客
06-28 1万+
排序：排序就是对某项数据按照特定的要求，比如大小或字符长短等按照升序或降序排序。排序过程中设计稳定性，稳定性指的是若有两个相同的数字，比如1和1。如果排序前1在1的前面，排完序后1还在1的前面。那么就说这个排序算法是稳定的，相反则说明不稳定。注意：如果本身就是一个稳定的排序，可以将其变成不稳定排序；如果本身就是不稳定排序，不能变成稳定的排序。常见的排序方法 上面是基于比较的排序。下面一个一个的分析一：直接插入排序 直接插入排序指的是将新的数据插入在已经排好序的序列中。比如我们生活中的玩的斗地主，我们需要将新
深入理解ThreadLocal
技术人生
09-09 3160
一. ThreadLocal是什么？ ThreadLocal，顾名思义，它不是一个线程，而是线程的一个本地化对象。当工作于多线程中的对象使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程分配一个独立的初始化变量副本。所以每一个线程都可以独立地改变自己的副本，而不会影响其他线程所对应的副本。从线程的角度看，这个变量就像是线程的本地变量，这也是类名中“Local”所要表达的意思。
Java多线程（全知识点）
jakelihua
10-26 375
本文为Java多线程的基础知识点的第一部分，主要包括，通过继承Thread来实现进程，线程调度，线程控制，run(),start(),join(),sleep(),setDaemon()方法的使用，获取线程名字currentThread()，线程同步，非静态锁，静态方法的锁，Lock锁，生产者与消费者问题，卖票问题。
多线程---并发容器的使用
意田天的博客
08-13 1万+
多线程---并发容器的使用1. 容器概览2. 容器的使用1. Map1. HashTable2. HashMap3. SynchronizedHashMap4. ConcurrentHashMap2. Collection1. ArrayList2. Vector3. LinkedList4. ConcurrentLinkedQueue3. 并发容器的使用1. ConcurrentHashMap2. CopyOnWriteArrayList3. ConcurrentLinkedQueue4. LinkedB
Java并发：同步容器&并发容器
12-22
同步容器可以简单地理解为通过synchronized来实现同步的容器，比如Vector、Hashtable以及SynchronizedList等容器，如果有多个线程调用同步容器的方法，它们将会串行执行。 　可以通过查看Vector、Hashtable等同步...
25 经典并发容器，多线程面试必备—深入解析ConcurrentHashMap下.pdf
06-15
Java并发编程学习宝典（漫画版），Java并发编程学习宝典（漫画版）Java并发编程学习宝典（漫画版）Java并发编程学习宝典（漫画版）Java并发编程学习宝典（漫画版）Java并发编程学习宝典（漫画版）Java并发编程学习...
Jdk提供线程池-原理、解析和使用
逐梦追风_博客
03-15 290
1.背景 我们都很清楚java创建线程的方式：1.继承Thread 2.实现Runnable接口，但是在项目中，我们几乎从来不会这样使用，因为线程创建和销毁都很耗费系统资源（CPU、IO、内存等），那么问题来了，如果能有一种工具能在我们需要的时候（eg：前端页面请求、后端定时任务等）提供创建线程，当线程执行完成以后不进行销毁，直接被工具回收回去，进入闲置状态，等待被再次使用。这样的话，资源利用率就...
java学习之container
jingza的博客
07-18 491
注意：在容器已经显示出来之后，就不能再向容器增加组件，不然会不会显示。 如下： （1）.不会显示 dw.setVisible(true); dw.add(new Button("ok"));（2）显示 dw.add(new Button("ok")); dw.setVisible(true);
java获取随机数(java获取随机数整数)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-10 7038
在Java中产生随机数有什么方法？ 最后的结果就是生成1到100之间的随机偶数。其实，如果要范围随机奇数的话，至需要对上面的语句进行稍微的修改即可。Java: 改变你我的世界 假设现在用户想生成一个任意范围内的奇数或者偶数，能够实现吗?假设现在用户想实现一个m到n之间的任意偶数(其中m 可见虽然random方...
【Java多线程】并发容器
ChrisLee2013的博客
07-20 81
ConcurrentHashMap CopyOnWriteArrayList CopyOnWriteArraySet ConcurrentLinkedQueue oncurrentLinkedDueue ConcurrentSkipListMap ConcurrentSkipListSet ArrayBlockingQueue LinkedBlockingQueue LinkedBlockingDueue PriorityBlockingQueue SynchronousQueue LinkedTransf
container在java里怎么用,十年阿里顶级架构师教你怎么使用Java来搭建微服务
weixin_29945371的博客
03-18 474
原标题：十年阿里顶级架构师教你怎么使用Java来搭建微服务微服务背后的大理念是将大型、复杂且历时长久的应用在架构上设计为内聚的服务，这些服务能够随着时间的流逝而演化。本文主要介绍了利用 Java 生态系统构建微服务的多种方法，并分析了每种方法的利弊。快速预览在 Java 生态系统中构建微服务的策略主要有：container-less, self-contained 和 in-container；C...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 893
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 493
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
C# 并发容器和线程锁
10-28
C#并发容器和线程锁都是用来解决多线程并发访问共享资源时可能出现的数据竞争问题的。线程锁是一种传统的解决方案，通过在代码块中加锁来保证同一时间只有一个线程可以访问共享资源。而并发容器则是一种更加高效的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值