多线程系列教材（四）- 常见的线程安全相关的面试题

多线程系列教材（三）- Java 多线程同步 synchronized 详解

多线程系列教材（五）- Java 演示多线程死锁

工具版本兼容问题

常见的线程安全相关的面试题

纠

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

6分18秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

步骤 1 : HashMap和Hashtable的区别
步骤 2 : StringBuffer和StringBuilder的区别
步骤 3 : ArrayList和Vector的区别
步骤 4 : 把非线程安全的集合转换为线程安全
步骤 5 : 练习-线程安全的MyStack
步骤 6 : 答案-线程安全的MyStack

步骤 1 :

HashMap和Hashtable的区别

edit 顶折

纠问

HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null
Hashtable不能存放null
区别2：
HashMap不是线程安全的类
Hashtable是线程安全的类

步骤 2 :

StringBuffer和StringBuilder的区别

edit 顶折

纠问

StringBuffer 是线程安全的
StringBuilder 是非线程安全的

所以当进行大量字符串拼接操作的时候，如果是单线程就用StringBuilder会更快些，如果是多线程，就需要用StringBuffer 保证数据的安全性

非线程安全的为什么会比线程安全的快？因为不需要同步嘛，省略了些时间

步骤 3 :

ArrayList和Vector的区别

edit 顶折

纠问

通过在eclipse中查看源代码可以得知：

ArrayList类的声明：

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector类的声明：

public class Vector<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

一模一样的~
他们的区别也在于，Vector是线程安全的类，而ArrayList是非线程安全的。

步骤 4 :

把非线程安全的集合转换为线程安全

edit 顶折

纠问

ArrayList是非线程安全的，换句话说，多个线程可以同时进入一个ArrayList对象的add方法

借助Collections.synchronizedList，可以把ArrayList转换为线程安全的List。

与此类似的，还有HashSet,LinkedList,HashMap等等非线程安全的类，都通过工具类Collections转换为线程安全的

package multiplethread;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestThread {
   
    public static void main(String[] args) {
    	List<Integer> list1 = new ArrayList<>();
    	List<Integer> list2 = Collections.synchronizedList(list1);
    }
       
}

步骤 5 :

练习-线程安全的MyStack

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

借助把非线程安全的集合转换为线程安全，用另一个方式完成练习-线程安全的MyStack

步骤 6 :

答案-线程安全的MyStack

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

2分22秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

把LinkedList通过 Collections.synchronizedList转换成了一个线程安全的List

List<Hero> heros = (List<Hero>) Collections.synchronizedList(new LinkedList<Hero>());

不需要在push上加synchronized修饰符
虽然多个线程可以同时进入push方法，但是调用heros.add方法的时候
同一时间，只有一个线程可以进入

public void push(Hero h) {
heros.add(h);
}

代码行数较多，请点击查看

package collection;
    
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
 
import charactor.Hero;
    
public class MyStack implements Stack{
    
    //把LinkedList通过 Collections.synchronizedList转换成了一个线程安全的List
    List<Hero> heros = (List<Hero>) Collections.synchronizedList(new LinkedList<Hero>());
 
    //不需要在push上加synchronized修饰符
    //虽然多个线程可以同时进入push方法，但是调用heros.add方法的时候 
    //同一时间，只有一个线程可以进入
    public void push(Hero h) {
        heros.add(h);
    }
    
    public Hero pull() {
        return heros.remove(heros.size()-1);
    }
    
    public Hero peek() {
        return heros.get(heros.size()-1);
    }
}

多线程系列教材（三）- Java 多线程同步 synchronized 详解

多线程系列教材（五）- Java 演示多线程死锁

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-31 答案-线程安全的MyStack

木宇

关于 JAVA 中级-多线程-线程安全的类的提问

答案-线程安全的MyStack

package com.cwt.study.java中级.s_20240731;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class MyStack implements Stack {
    List<Hero> heros = new LinkedList<Hero>();
    List<Hero> heros1 =Collections.synchronizedList(heros);
    //插入
    public  void push(Hero h) {
        heros1.add(h);
    }
    //删除
    public  Hero pull() {
        return heros1.remove(heros1.size()-1);
    }

    //查看
    public  Hero peek() {
        return heros1.get(heros1.size()-1);
    }

    public static void main(String[] args) {

        MyStack heroStack = new MyStack();
        for (int i = 0; i < 5; i++) {
            Hero h = new Hero("hero name " + i);
            System.out.println("压入 hero:" + h);
            heroStack.push(h);
        }
        for (int i = 0; i < 5; i++) {
            Hero h =heroStack.pull();
            System.out.println("弹出 hero" + h);

        }
        heroStack.peek();
        System.out.println( heroStack.peek());
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2024-07-30 练习-线程安全的MyStack

木宇

关于 JAVA 中级-多线程-线程安全的类的提问

练习-线程安全的MyStack

package com.cwt.study.java中级.s_20240729;

import java.util.LinkedList;

public class TestThreadTest2 implements Stack{
    LinkedList<Hero> heros = new LinkedList<Hero>();
    //插入
    public synchronized void push(Hero h) {
        heros.addLast(h);
    }
    //删除
    public synchronized Hero pull() {
        return heros.removeLast();
    }

    //查看
    public synchronized Hero peek() {
        return heros.getLast();
    }

    public static void main(String[] args) {

        TestThreadTest2 heroStack = new TestThreadTest2();
        for (int i = 0; i < 5; i++) {
            Hero h = new Hero("hero name " + i);
            System.out.println("压入 hero:" + h);
            heroStack.push(h);
        }
        for (int i = 0; i < 5; i++) {
            Hero h =heroStack.pull();
            System.out.println("弹出 hero" + h);
        }
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2024-07-13 感觉用Collections方法间接实现MyStack线程安全有问题

虚心求学

关于 JAVA 中级-多线程-线程安全的类的提问

以下是我的一些拙见，恳请大家批评指正。事实上，Stack.pull()这个方法不是线程安全的。因为这个方法内部使用 heros.remove(heros.size()-1) 来删除数据，remove和heros.size()本身就不能保证在删除的时候不会被其他线程所影响。即使说heros是用collections转换而成的线程安全的链表，但 value.remove()和heros.size()这个操作仍然不是线程安全的。因此正确解法是，在Stack.pull() 前面加上synchronized声明。如果不加上synchronized声明会出现错误：如截图所示。加上synchronized后，感觉Collections.synchronizedList()这个方法似乎在这个例子中有有些多余，因为即使list线程安全了，但是stack部分方法是间接安全的，而某些方法又是不稳定的（可能会出现脏数据的情况）。加上synchronized声明后的运行结果：初始值 size:1 [[teemo，1，20]] 栈的大小为：1 对栈做同等次数（10000）的入栈、出栈操作增减线程运行后： size:1 [[teemo，1，20]] 栈的大小为：1

package j2se;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class MyStack<E> implements Stack<E> {

	private List<E> value = Collections.synchronizedList(new LinkedList<>());

	@Override
	public  void push(E element) {
		value.add(element);
	}

	@Override
	public synchronized E pull() {
		if (!value.isEmpty())
		{
			return value.remove(value.size()-1);
		}
		else
			return null;
	}

	@Override
	public  E peek() {
		if (!value.isEmpty())
			return value.get(value.size()-1);
		else
			return null;
	}
	public  int size()
	{
		return value.size();
	}
	@Override
	public  String toString() {
		if (value.isEmpty())return null;
		String res = "size:"+size();
		try {
			res = "size:"+size()+" "+value.toString();
		} catch (Throwable e) {
			//e.printStackTrace();
			return "size:"+size()+" Error";
			// TODO: handle exception
		}
		return res;
	}

	public void print() {
		System.out.println(this);
	}

}

如果不加上synchronized声明会出现以下错误：
Exception in thread "Thread-15233" java.lang.IndexOutOfBoundsException: Index: 4768, Size: 4768
	at java.util.LinkedList.checkElementIndex(LinkedList.java:555)
	at java.util.LinkedList.remove(LinkedList.java:525)
	at java.util.Collections$SynchronizedList.remove(Collections.java:2426)
	at j2se.MyStack.pull(MyStack.java:27)
	at testThread.TestThread.lambda$1(TestThread.java:40)
	at java.lang.Thread.run(Thread.java:745)

1 个答案

虚心求学
答案时间：2024-07-13

测试MyStack是否真的线程安全的方法是： 1.开辟新线程进行1万次入栈操作，不断加入新数据 2.开辟新线程进行1万次出栈操作，不断移除旧数据 3.主线程等待上述两个过程结束。如果栈里面的元素没有变化，说明MyStack确实是线程安全。因为理论上，同样数量的增、减操作后，栈的总数没有变化。如果发生了变化，栈总数多了或少了，都说明 MyStack 执行入栈出栈操作时不是线程安全的，有脏数据产生。

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-06-21 答案

2021-08-05 练习 - 线程安全的MyStack的Collections用法

起个名	关于 JAVA 中级-多线程-线程安全的类的提问问题截图代码异常借助把非线程安全的集合转换为线程安全，用另一个方式完成线程安全的MyStack MyStack stack = new MyStack(); LinkedList<Hero> ll1 = (LinkedList<Hero>) Collections.synchronizedList(stack.ll);

1 个答案

hoolich
答案时间：2022-04-24

/* 借助把非线程安全的集合转换为线程安全，用另一个方式完成练习-线程安全的MyStack */ package collection; import charactor.Hero; import java.util.Collections; import java.util.LinkedList; public class MyStack implements Stack{ LinkedList<Hero> heros = (LinkedList<Hero>)Collections.synchronizedList(new LinkedList<Hero>()); public void push(Hero h){ heros.addLast(h); } public Hero pull(){ return heros.removeLast(); } public Hero peek(){ return heros.getLast(); } public static void main(String[] args) { MyStack heroStack = new MyStack(); // 第一种遍历 for循环 System.out.println("--------for 循环-------"); for (int i = 0; i < 5; i++) { Hero h=new Hero("hero "+i); System.out.println("压入 hero:" + h.name); heroStack.push(h); } for (int i = 0; i < 5; i++) { Hero h =heroStack.pull(); System.out.println("弹出 hero:" + h.name); } heroStack.peek(); } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 7 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于 JAVA 中级-多线程-线程安全的类的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 578362961

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： https://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图