我们开启三个线程同时向集合中添加数据,每个线程向集合中添加1000个数据,正常情况下集合的长度应该是3000,但因为有些集合是非线程安全的,所以在添加过程中会出现问题,导致集合的实际长度不到3000
List集合
实现类:
非线程安全:ArrayList,LinkedList
线程安全:Vector
ArrayList
public class MyTest18 {
static List<Integer> list = new ArrayList<Integer>();
public static void main(String[] args) throws InterruptedException {
// 输出十次列表长度
for (int i = 0;i < 10;i++){
// 创建3个线程
for (int j = 0;j < 3;j++){
new Thread(new Runnable() {
@Override
public void run() {
// 每个线程向list中添加1000个整数
for (int z = 0;z < 1000;z++){
list.add(z);
}
}
}).start();
}
// 等待所有线程执行完
Thread.sleep(2000);
// 输出list的长度
System.out.println(list.size());
// 清空列表
list.clear();
}
}
}
LinkedList
public class MyTest18 {
static List<Integer> list = new LinkedList<Integer>();
public static void main(String[] args) throws InterruptedException {
// 输出十次列表长度
for (int i = 0;i < 10;i++){
// 创建3个线程
for (int j = 0;j < 3;j++){
new Thread(new Runnable() {
@Override
public void run() {
// 每个线程向list中添加1000个整数
for (int z = 0;z < 1000;z++){
list.add(z);
}
}
}).start();
}
// 等待所有线程执行完
Thread.sleep(2000);
// 输出list的长度
System.out.println(list.size());
// 清空列表
list.clear();
}
}
}
Vector
public class MyTest18 {
static List<Integer> list = new Vector<Integer>();
public static void main(String[] args) throws InterruptedException {
// 输出十次列表长度
for (int i = 0;i < 10;i++){
// 创建3个线程
for (int j = 0;j < 3;j++){
new Thread(new Runnable() {
@Override
public void run() {
// 每个线程向list中添加1000个整数
for (int z = 0;z < 1000;z++){
list.add(z);
}
}
}).start();
}
// 等待所有线程执行完
Thread.sleep(2000);
// 输出list的长度
System.out.println(list.size());
// 清空列表
list.clear();
}
}
}
因为Vector是线程安全的,所以列表的实际长度就是3000
Map集合
实现类:
非线程安全:HashMap,TreeMap
线程安全:Hashtable
HashMap
public class MyTest19 {
static Map<Integer,Integer> map = new HashMap<Integer, Integer>();
public static void main(String[] args) throws InterruptedException {
// 循环输出map长度10次
for (int i = 0;i < 10;i++){
// 创建三个线程
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围 2000-2999
map.put(2*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围3000-3999
map.put(3*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围4000-4999
map.put(4*1000+i,2);
}
}
}).start();
// 等待线程执行完
Thread.sleep(2000);
// 输出map长度
System.out.println(map.size());
// 清空map
map.clear();
}
}
}
TreeMap
public class MyTest19 {
static Map<Integer,Integer> map = new TreeMap<Integer, Integer>();
public static void main(String[] args) throws InterruptedException {
// 循环输出map长度10次
for (int i = 0;i < 10;i++){
// 创建三个线程
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围 2000-2999
map.put(2*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围3000-3999
map.put(3*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围4000-4999
map.put(4*1000+i,2);
}
}
}).start();
// 等待线程执行完
Thread.sleep(2000);
// 输出map长度
System.out.println(map.size());
// 清空map
map.clear();
}
}
}
Hashtable
public class MyTest19 {
static Map<Integer,Integer> map = new Hashtable<Integer, Integer>();
public static void main(String[] args) throws InterruptedException {
// 循环输出map长度10次
for (int i = 0;i < 10;i++){
// 创建三个线程
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围 2000-2999
map.put(2*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围3000-3999
map.put(3*1000+i,2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 1000;i++){
// 键范围4000-4999
map.put(4*1000+i,2);
}
}
}).start();
// 等待线程执行完
Thread.sleep(2000);
// 输出map长度
System.out.println(map.size());
// 清空map
map.clear();
}
}
}
因为Hashtable是线程安全的,所以集合的实际长度是3000