并发包CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap

[一切如你i]

并发包

CopyOnWriteArrayList

/*
    ArrayList是线程不安全的，多个线程一起对ArrayList进行操作有可能会有安全问题
    CopyOnWriteArrayList是线程安全的，可以使用它来解决这个问题
 */
public class Task implements Runnable{
    //定义集合【ArrayList是线程不安全的，会引发线程安全问题】
    //List<Integer> list = new ArrayList<>();

    //CopyOnWriteArrayList是线程安全的，可以使用它来解决这个问题
    List<Integer> list = new CopyOnWriteArrayList<>();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.add(i);
        }
        System.out.println("添加完毕");
    }
}

public class Demo01Test {
    public static void main(String[] args) throws InterruptedException {
        //创建Task对象
        Task task = new Task();
        //创建三个线程，并执行任务
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();

        //线程休眠
        Thread.sleep(3000);

        //输出集合的大小
        System.out.println(task.list.size());
    }
}

CopyOnWriteArraySet

public class Demo01Test {
    public static void main(String[] args) throws InterruptedException {
        //创建Task对象
        Task t = new Task();
        //创建线程，启动
        new Thread(t).start();
        //在main线程中向集合中添加2000-3000之间的数字
        for (int i = 2000; i < 3000; i++) {
            Thread.sleep(5);
            t.set.add(i);
        }
        //休眠
        Thread.sleep(7000);
        //输出集合的大小
        System.out.println("集合的大小是：" + t.set.size());
    }
}

/*
    HashSet线程不安全，如果多线程同时对HashSet集合进行操作，有可能会产生安全性的问题
    CopyOnWriteArraySet是线程安全的，我们可以使用这个集合进行多线程操作
 */
public class Task implements Runnable{
    //创建HashSet集合【HashSet线程不安全，如果多线程同时对HashSet集合进行操作，有可能会产生安全性的问题】
    //Set<Integer> set = new HashSet<>();

    //CopyOnWriteArraySet是线程安全的，我们可以使用这个集合进行多线程操作
    Set<Integer> set = new CopyOnWriteArraySet<>();

    @Override
    public void run() {
        //向集合中添加数据
        for (int i = 0; i < 1000; i++) {
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //添加数据
            set.add(i);
        }
        System.out.println("添加完成");
    }
}

ConcurrentHashMap

/*
    HashMap集合不是线程安全的，如果多个线程同时操作HashMap，那么有可能会引发线程安全问题。
    Hashtable集合是线程安全的，多个线程同时操作hashtable不会引发线程安全问题，效率非常低，目前基本已经淘汰了。
    ConcurrentHashMap集合是线程安全的，但是效率相对Hashtable要高。 

 */
public class Task implements Runnable{
    //创建Map集合
    Map<String, String> map = new ConcurrentHashMap<>();

    @Override
    public void run() {
        //定义循环，在循环中向Map集合中添加10000条数据
        for (int i = 0; i < 10000; i++) {
            //向map集合中添加数据
            map.put(Thread.currentThread().getName() + i, Thread.currentThread().getName() + i);
        }
    }
}

public class Demo01Test {
    public static void main(String[] args) throws InterruptedException {
        //创建Task对象
        Task task = new Task();
        //创建三个线程对象，执行任务
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        //线程休眠
        Thread.sleep(3000);
        //输出map集合的大小
        System.out.println(task.map.size());
    }
}