首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

使用3个线程将元素添加到5个ArrayList中:数组大小的总和总是不同的

使用3个线程将元素添加到5个ArrayList中,数组大小的总和总是不同的。

答案: 在这个问题中,我们可以使用多线程编程来实现将元素添加到5个ArrayList中。为了确保数组大小的总和总是不同的,我们可以使用线程同步机制来避免并发访问问题。

首先,我们需要创建5个ArrayList对象,用于存储元素。然后,我们创建3个线程,每个线程负责向这5个ArrayList中添加元素。

在每个线程中,我们可以使用互斥锁(mutex)来确保同一时间只有一个线程能够访问ArrayList。这可以通过在添加元素之前获取锁,并在添加完成后释放锁来实现。

以下是一个示例代码:

代码语言:txt
复制
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ArrayListThreadExample {
    private static ArrayList<Integer> arrayList1 = new ArrayList<>();
    private static ArrayList<Integer> arrayList2 = new ArrayList<>();
    private static ArrayList<Integer> arrayList3 = new ArrayList<>();
    private static ArrayList<Integer> arrayList4 = new ArrayList<>();
    private static ArrayList<Integer> arrayList5 = new ArrayList<>();
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                arrayList1.add(i);
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 10; i < 20; i++) {
                lock.lock();
                arrayList2.add(i);
                lock.unlock();
            }
        });

        Thread thread3 = new Thread(() -> {
            for (int i = 20; i < 30; i++) {
                lock.lock();
                arrayList3.add(i);
                lock.unlock();
            }
        });

        Thread thread4 = new Thread(() -> {
            for (int i = 30; i < 40; i++) {
                lock.lock();
                arrayList4.add(i);
                lock.unlock();
            }
        });

        Thread thread5 = new Thread(() -> {
            for (int i = 40; i < 50; i++) {
                lock.lock();
                arrayList5.add(i);
                lock.unlock();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();

        try {
            thread1.join();
            thread2.join();
            thread3.join();
            thread4.join();
            thread5.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("ArrayList1: " + arrayList1);
        System.out.println("ArrayList2: " + arrayList2);
        System.out.println("ArrayList3: " + arrayList3);
        System.out.println("ArrayList4: " + arrayList4);
        System.out.println("ArrayList5: " + arrayList5);
    }
}

在这个示例中,我们使用了ReentrantLock来实现互斥锁。每个线程在添加元素之前都会获取锁,并在添加完成后释放锁。这样可以确保每个线程在操作ArrayList时不会被其他线程干扰。

最后,我们通过输出每个ArrayList的内容来验证结果。

请注意,以上示例代码仅为演示多线程操作ArrayList的思路,并不涉及具体的腾讯云产品。对于云计算领域的具体应用场景和推荐产品,可以根据实际需求进行选择。

页面内容是否对你有帮助?
有帮助
没帮助

相关·内容

  • 【深入理解java集合系列】ArrayList实现原理

    ArrayList是List接口的可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。 每个ArrayList实例都有一个容量,该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素,其容量也自动增长。自动增长会带来数据向新数组的重新拷贝,因此,如果可预知数据量的多少,可在构造ArrayList时指定其容量。在添加大量元素前,应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量,这可以减少递增式再分配的数量。 注意,此实现不是同步的。如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。

    01

    面试系列之-同步容器与高并发容器(JAVA基础)

    除了提供对SortedSet进行同步包装的方法之外,java.util.Collections还提供了一系列对其他的基础容器进行同步包装的方法,如synchronizedList()方法将基础List包装成线程安全的列表容器,synchronizedMap()方法将基础Map容器包装成线程安全的容器,synchronizedCollection()方法将基础Collection容器包装成线程安全的Collection容器与同步包装方法相对应,java.util.Collections还提供了一系列同步包装类,这些包装类都是其内部类。这些同步包装类的实现逻辑很简单:实现了容器的操作接口,在操作接口上使用synchronized进行线程同步,然后在synchronized的临界区将实际的操作委托给被包装的基础容器。‍高并发容器:‍ JUC高并发容器是基于非阻塞算法(或者无锁编程算法)实现的容器类,无锁编程算法主要通过CAS(Compare And Swap)+Volatile组合实现,通过CAS保障操作的原子性,通过volatile保障变量内存的可见性。无锁编程算法的主要优点如下: (1)开销较小:不需要在内核态和用户态之间切换进程。 (2)读写不互斥:只有写操作需要使用基于CAS机制的乐观锁, 读读操作之间可以不用互斥。 JUC包中提供了List、Set、Queue、Map各种类型的高并发容器,如ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList和CopyOnWriteArraySet。在性能上,ConcurrentHashMap通常优于同步的HashMap,ConcurrentSkipListMap通常优于同步的TreeMap。当读取和遍历操作远远大于列表的更新操作时,CopyOnWriteArrayList优于同步的ArrayList。 List:JUC包中的高并发List主要有CopyOnWriteArrayList,对应的基础容器为ArrayList。CopyOnWriteArrayList相当于线程安全的ArrayList,它实现了List接口。在读多写少的场景中,其性能远远高于ArrayList的同步包装容器。 Set:·CopyOnWriteArraySet继承自AbstractSet类,对应的基础容器为HashSet。其内部组合了一个CopyOnWriteArrayList对象,它的核心操作是基于CopyOnWriteArrayList实现的。 ·ConcurrentSkipListSet是线程安全的有序集合,对应的基础容器为TreeSet。它继承自AbstractSet,并实现了NavigableSet接口。ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的。 Map:·ConcurrentHashMap对应的基础容器为HashMap。JDK 6中的ConcurrentHashMap采用一种更加细粒度的“分段锁”加锁机制,JDK 8中采用CAS无锁算法。 ·ConcurrentSkipListMap对应的基础容器为TreeMap。其内部的SkipList(跳表)结构是一种可以代替平衡树的数据结构,默认是按照Key值升序的。 Queue:JUC包中的Queue的实现类包括三类:单向队列、双向队列和阻塞队列。 ·ConcurrentLinkedQueue是基于列表实现的单向队列,按照FIFO(先进先出)原则对元素进行排序。新元素从队列尾部插入,而获取队列元素则需要从队列头部获取。 ·ConcurrentLinkedDeque是基于链表的双向队列,但是该队列不允许null元素。ConcurrentLinkedDeque可以当作“栈”来使用,并且高效地支持并发环境。 ·ArrayBlockingQueue:基于数组实现的可阻塞的FIFO队列。 ·LinkedBlockingQueue:基于链表实现的可阻塞的FIFO队列。 ·PriorityBlockingQueue:按优先级排序的队列。 ·DelayQueue:按照元素的Delay时间进行排序的队列。 ·SynchronousQueue:无缓冲等待队列。

    02
    领券