精华内容
下载资源
问答
  • java中的线程安全是什么: 就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问。 什么叫线程...

    java中的线程安全是什么:

    就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问。

    什么叫线程安全:

    如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。

    或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

    线程安全问题都是由全局变量及静态变量引起的。
    若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则就可能影响线程安全。

    存在竞争的线程不安全,不存在竞争的线程就是安全的

    展开全文
  • 什么是线程安全?如何保证线程安全

    万次阅读 多人点赞 2019-05-27 23:22:44
    什么是线程安全 参考: 《Java并发编程实践》中对线程安全的定义: 当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作...

    什么是线程安全

    参考:

    《Java并发编程实践》中对线程安全的定义:

    当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为都可以获得正确的结果,那这个对象就是线程安全的。

    《深入理解Java虚拟机》的作者也认可这个观点。本人也认为这是一个恰当的定义,因为线程安全的主体是什么?是方法还是代码块?这里给出的主体是对象,这是非常恰当的,因为Java是纯面向对象的,Java中一切为对象。因此通过对象定义线程安全是恰当的。

    但是,这里并不是说其他的方式定义不对(这里绝没有这个意思)。我们可以看一下其他的定义方式,进行一下对比:

    当多个线程访问某个方法时,不管你通过怎样的调用方式或者说这些线程如何交替的执行,我们在主程序中不需要去做任何的同步,这个类的结果行为都是我们设想的正确行为,那么我们就可以说这个类时线程安全的。
    如果一段代码可以保证多个线程访问的时候正确操作共享数据,那么它是线程安全的

    多线程编程中的三个核心概念

    • 原子性

    这一点,跟数据库事务的原子性概念差不多,即一个操作(有可能包含有多个子操作)要么全部执行(生效),要么全部都不执行(都不生效)。

    关于原子性,一个非常经典的例子就是银行转账问题:比如A和B同时向C转账10万元。如果转账操作不具有原子性,A在向C转账时,读取了C的余额为20万,然后加上转账的10万,计算出此时应该有30万,但还未来及将30万写回C的账户,此时B的转账请求过来了,B发现C的余额为20万,然后将其加10万并写回。然后A的转账操作继续——将30万写回C的余额。这种情况下C的最终余额为30万,而非预期的40万。

    • 可见性

    可见性是指,当多个线程并发访问共享变量时,一个线程对共享变量的修改,其它线程能够立即看到。可见性问题是好多人忽略
    或者理解错误的一点。

    CPU从主内存中读数据的效率相对来说不高,现在主流的计算机中,都有几级缓存。每个线程读取共享变量时,都会将该变量加载进其对应CPU的高速缓存里,修改该变量后,CPU会立即更新该缓存,但并不一定会立即将其写回主内存(实际上写回主内存的时间不可预期)。此时其它线程(尤其是不在同一个CPU上执行的线程)访问该变量时,从主内存中读到的就是旧的数据,而非第一个线程更新后的数据。

    这一点是操作系统或者说是硬件层面的机制,所以很多应用开发人员经常会忽略。

    • 有序性

    顺序性指的是,程序执行的顺序按照代码的先后顺序执行。

    以下面这段代码为例

    boolean started = false; // 语句1    
    long counter = 0L; // 语句2    
    counter = 1; // 语句3    
    started = true; // 语句4 
    

    从代码顺序上看,上面四条语句应该依次执行,但实际上JVM真正在执行这段代码时,并不保证它们一定完全按照此顺序执行。

    处理器为了提高程序整体的执行效率,可能会对代码进行优化,其中的一项优化方式就是调整代码顺序,按照更高效的顺序执行代码。

    讲到这里,有人要着急了——什么,CPU不按照我的代码顺序执行代码,那怎么保证得到我们想要的效果呢?实际上,大家大可放心,CPU虽然并不保证完全按照代码顺序执行,但它会保证程序最终的执行结果和代码顺序执行时的结果一致。

    如何实现线程安全

    • 第一种 : 互斥同步

    何谓同步?在多线程编程中,同步就是一个线程进入监视器(可以认为是一个只允许一个线程进入的盒子),其他线程必须等待,直到那个线程退出监视器为止。

    在实现互斥同步的方式中,最常使用的就是Synchronized 关键字。

    synchronized实现同步的基础就是:Java中的每一个对象都可以作为锁。

    具体表现为:1.普通同步方法,锁是当前实例对象

                         2.静态同步方法,锁是当前类的Class对象
    
                         3.同步方法块,锁是Synchronized括号里匹配的对象
    
    • 如何实现?

      • synchronized经过编译之后,会在同步块的前后生成 monitorenter 和monitorexit这两个字节码指令。这两个字节码指令之后有一个reference类型(存在于java虚拟机栈的局部变量表中,可以根据reference数据,来操作堆上的具体对象)的参数来指明要锁定和解锁的对象。根据虚拟机规范,在执行monitorenter 指令时,首先会尝试获取对象的锁,如果该对象没有被锁定,或者当前线程已经拥有了那个对象的锁,把锁的计数器加一。若获取对象失败,那当前线程就要阻塞等待,知道对象锁被另一个线程释放。

      • synchronized用的锁是存放在对象头里面的,在jdk1.6之后,锁一共有四种状态:无锁状态,偏向锁状态(在对象头和栈帧中的锁记录里存储偏向锁的线程id),轻量级锁状态(将对象头的mark word复制到当前线程的栈帧的锁记录中,使用CAS操作将对象头中的markWord指向栈帧中的锁记录,如果成功,则线程就拥有了对象的锁。如果两个以上的线程争用一把锁的话,则膨胀为重量级锁),重量级锁状态。

      因为之前我一直都很迷惑,所以我接下来讲一讲这一方面 :

      大家应该都知道,java 在虚拟机中除了线程计数器,java虚拟机栈 是线程私有的,其余的java堆,方法区,和运行时常量池都是线程共享的内存区域。java堆是存储对象和数组的,但是对象在内存中的存储布局可以分为三块区域:对象头,实例数据(对象真正存储的有效信息,程序代码中所定义的各个类型的字段内容),对齐填充。

      为什么说synchronized的锁是存放在对象头里面呢?因为对象头里面也存储了两部分信息:第一部分呢,存储对象自身的运行时数据,包括哈希码,GC分代年龄,锁状态标识位,线程持有的锁,偏向锁Id,偏向时间戳等数据。第二部分是类型指针,虚拟机通过这个来确定该对象是哪个类的实例。

      如何判断该对象有没有被锁?对象头里面锁状态的标志位会发生变化,当其他线程查看synchronized 锁定的对象时,会查看该对象的对象头的标志位有没有发生变化,若标志位为01,则表示未锁定,为00时,则表示轻量级锁定,为10时,则为重量级锁定状态。为01时,则为偏向锁,为11时,则为GC标记状态。

    除了synchronized 关键字之外,还可以使用JUC包下的重入锁来实现同步 。

    • 第二种方法就是:非阻塞同步

      因为使用synchronized的时候,只能有一个线程可以获取对象的锁,其他线程就会进入阻塞状态,阻塞状态就会引起线程的挂起和唤醒,会带来很大的性能问题,所以就出现了非阻塞同步的实现方法。

        先进行操作,如果没有其他线程争用共享数据,那么操作就成功了,如果共享数据有争用,就采取补偿措施(不断地重试)。
        
        我们想想哈,互斥同步里实现了 操作的原子性(这个操作没有被中断) 和 可见性(对数据进行更改后,会立马写入到内存中,其他线程在使用到这个数据时,会获取到最新的数据),那怎么才能不用同步来实现原子性和可见性呢? 
        
        CAS是实现非阻塞同步的计算机指令,它有三个操作数:内存位置,旧的预期值,新值,在执行CAS操作时,当且仅当内存地址的值符合旧的预期值的时候,才会用新值来更新内存地址的值,否则就不执行更新。
        
           使用方法:使用JUC包下的整数原子类decompareAndSet()和getAndIncrement()方法
        
        缺点 :ABA 问题  版本号来解决
        
        只能保证一个变量的原子操作,解决办法:使用AtomicReference类来保证对象之间的原子性。可以把多个变量放在一个对象里。
      
    • 第三种:无同步方案

      线程本地存储:将共享数据的可见范围限制在一个线程中。这样无需同步也能保证线程之间不出现数据争用问题。

      经常使用的就是ThreadLocal类

      ThreadLocal类 最常见的ThreadLocal使用场景为 用来解决数据库连接、Session管理等。

        public T get() { }  
        public void set(T value) { }  
        public void remove() { }  
        protected T initialValue() { }  
           
      get()方法是用来获取ThreadLocal在当前线程中保存的变量副本,set()用来设置当前线程中变量的副本,remove()用来移除当前线程中变量的副本,initialValue()是一个protected方法,一般是用来在使用时进行重写的,它是一个延迟加载方法
      

      其实引起线程不安全最根本的原因 就是 :线程对于共享数据的更改会引起程序结果错误。线程安全的解决策略就是:保护共享数据在多线程的情况下,保持正确的取值。

    展开全文
  • Java线程安全和非线程安全

    万次阅读 多人点赞 2013-05-16 14:09:47
    ArrayList和Vector有什么区别?...面对这样的问题,回答是:ArrayList是非线程安全的,Vector是线程安全的;HashMap是非线程安全的,HashTable是线程安全的;StringBuilder是非线程安全的,StringBuff

    ArrayList和Vector有什么区别?HashMap和HashTable有什么区别?StringBuilder和StringBuffer有什么区别?这些都是Java面试中常见的基础问题。面对这样的问题,回答是:ArrayList是非线程安全的,Vector是线程安全的;HashMap是非线程安全的,HashTable是线程安全的;StringBuilder是非线程安全的,StringBuffer是线程安全的。因为这是昨晚刚背的《Java面试题大全》上面写的。此时如果继续问:什么是线程安全?线程安全和非线程安全有什么区别?分别在什么情况下使用?这样一连串的问题,一口老血就喷出来了…


    非线程安全的现象模拟

    这里就使用ArrayList和Vector二者来说明。

    下面的代码,在主线程中new了一个非线程安全的ArrayList,然后开1000个线程分别向这个ArrayList里面添加元素,每个线程添加100个元素,等所有线程执行完成后,这个ArrayList的size应该是多少?应该是100000个?

    public class Main
    {
    	public static void main(String[] args)
    	{
    		// 进行10次测试
    		for(int i = 0; i < 10; i++)
    		{
    			test();
    		}
    	}
    	
    	public static void test()
    	{
    		// 用来测试的List
    		List<Object> list = new ArrayList<Object>();
    		
    		// 线程数量(1000)
    		int threadCount = 1000;
    		
    		// 用来让主线程等待threadCount个子线程执行完毕
    		CountDownLatch countDownLatch = new CountDownLatch(threadCount);
    		
    		// 启动threadCount个子线程
    		for(int i = 0; i < threadCount; i++)
    		{
    			Thread thread = new Thread(new MyThread(list, countDownLatch));
    			thread.start();
    		}
    		
    		try
    		{
    			// 主线程等待所有子线程执行完成,再向下执行
    			countDownLatch.await();
    		}
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    		
    		// List的size
    		System.out.println(list.size());
    	}
    }
    
    class MyThread implements Runnable
    {
    	private List<Object> list;
    	
    	private CountDownLatch countDownLatch;
    	
    	public MyThread(List<Object> list, CountDownLatch countDownLatch)
    	{
    		this.list = list;
    		this.countDownLatch = countDownLatch;
    	}
    	
    	public void run()
    	{
    		// 每个线程向List中添加100个元素
    		for(int i = 0; i < 100; i++)
    		{
    			list.add(new Object());
    		}
    		
    		// 完成一个子线程
    		countDownLatch.countDown();
    	}
    }

    上面进行了10次测试(为什么要测试10次?因为非线程安全并不是每次都会导致问题)。

    输出结果:

    99946

    100000

    100000

    100000

    99998

    99959

    100000

    99975

    100000

    99996


    上面的输出结果发现,并不是每次测试结果都是100000,有好几次测试最后ArrayList的size小于100000,甚至时不时会抛出个IndexOutOfBoundsException异常。(如果没有这个现象可以多试几次)

    这就是非线程安全带来的问题了。上面的代码如果用于生产环境,就会有隐患就会有BUG了。


    再用线程安全的Vector来进行测试,上面代码改变一处,test()方法中

    List<Object> list = new ArrayList<Object>();
    改成

    List<Object> list = new Vector<Object>();

    再运行程序。


    输出结果:

    100000

    100000

    100000

    100000

    100000

    100000

    100000

    100000

    100000

    100000


    再多跑几次,发现都是100000,没有任何问题。因为Vector是线程安全的,在多线程操作同一个Vector对象时,不会有任何问题。

    再换成LinkedList试试,同样还会出现ArrayList类似的问题,因为LinkedList也是非线程安全的。


    二者如何取舍

    非线程安全是指多线程操作同一个对象可能会出现问题。而线程安全则是多线程操作同一个对象不会有问题。

    线程安全必须要使用很多synchronized关键字来同步控制,所以必然会导致性能的降低

    所以在使用的时候,如果是多个线程操作同一个对象,那么使用线程安全的Vector;否则,就使用效率更高的ArrayList。


    非线程安全!=不安全

    有人在使用过程中有一个不正确的观点:我的程序是多线程的,不能使用ArrayList要使用Vector,这样才安全。

    非线程安全并不是多线程环境下就不能使用。注意我上面有说到:多线程操作同一个对象。注意是同一个对象。比如最上面那个模拟,就是在主线程中new的一个ArrayList然后多个线程操作同一个ArrayList对象。

    如果是每个线程中new一个ArrayList,而这个ArrayList只在这一个线程中使用,那么肯定是没问题的。


    线程安全的实现

    线程安全是通过线程同步控制来实现的,也就是synchronized关键字。   

    在这里,我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter,并对他们分别进行了多线程测试。


    非线程安全的计数器:

    public class Main
    {
    	public static void main(String[] args)
    	{
    		// 进行10次测试
    		for(int i = 0; i < 10; i++)
    		{
    			test();
    		}
    	}
    	
    	public static void test()
    	{
    		// 计数器
    		Counter counter = new Counter();
    		
    		// 线程数量(1000)
    		int threadCount = 1000;
    		
    		// 用来让主线程等待threadCount个子线程执行完毕
    		CountDownLatch countDownLatch = new CountDownLatch(threadCount);
    		
    		// 启动threadCount个子线程
    		for(int i = 0; i < threadCount; i++)
    		{
    			Thread thread = new Thread(new MyThread(counter, countDownLatch));
    			thread.start();
    		}
    		
    		try
    		{
    			// 主线程等待所有子线程执行完成,再向下执行
    			countDownLatch.await();
    		}
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    		
    		// 计数器的值
    		System.out.println(counter.getCount());
    	}
    }
    
    class MyThread implements Runnable
    {
    	private Counter counter;
    	
    	private CountDownLatch countDownLatch;
    	
    	public MyThread(Counter counter, CountDownLatch countDownLatch)
    	{
    		this.counter = counter;
    		this.countDownLatch = countDownLatch;
    	}
    	
    	public void run()
    	{
    		// 每个线程向Counter中进行10000次累加
    		for(int i = 0; i < 10000; i++)
    		{
    			counter.addCount();
    		}
    		
    		// 完成一个子线程
    		countDownLatch.countDown();
    	}
    }
    
    class Counter
    {
    	private int count = 0;
    
    	public int getCount()
    	{
    		return count;
    	}
    
    	public void addCount()
    	{
    		count++;
    	}
    }

    上面的测试代码中,开启1000个线程,每个线程对计数器进行10000次累加,最终输出结果应该是10000000。

    但是上面代码中的Counter未进行同步控制,所以非线程安全。

    输出结果:

    9963727

    9973178

    9999577

    9987650

    9988734

    9988665

    9987820

    9990847

    9992305

    9972233


    稍加修改,把Counter改成线程安全的计数器:

    class Counter
    {
    	private int count = 0;
    
    	public int getCount()
    	{
    		return count;
    	}
    
    	public synchronized void addCount()
    	{
    		count++;
    	}
    }

    上面只是在addCount()方法中加上了synchronized同步控制,就成为一个线程安全的计数器了。再执行程序。

    输出结果:

    10000000

    10000000

    10000000

    10000000

    10000000

    10000000

    10000000

    10000000

    10000000

    10000000


    作者:叉叉哥   转载请注明出处:http://blog.csdn.net/xiao__gui/article/details/8934832



    展开全文
  • 线程安全 & 线程安全函数 & 线程不安全函数 线程安全 就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不...

    线程安全 & 线程安全函数 & 线程不安全函数

      线程安全 就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。
      如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。
      一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
      线程不安全 就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据

    线程不安全函数主要分为以下四大类:

    第1类:不保护共享变量的函数,

    函数中访问全局变量和堆。
    共享变量在多线程中是共享数据比如全局变量和堆,如果不保护共享变量,多线程时会出bug。
    可以通过同步机制来保护共享数据,比如加锁。

    第2类:函数中分配,重新分配释放全局资源。

    与上面第一点基本相同,通过加锁可解决

    第3类:返回指向静态变量的指针的函数,函数中通过句柄和指针的不直接访问。

    比如,我们要计算a,b两个变量的和,于是将a,b的指针传入某一个函数,然而此时可能有另一个线程改变了a,b的值,此时在函数中我们通过地址取到的两个数的值已经改变了,所以计算出的结果也就是错的了。
    又比如某些函数(如gethostbyname)将计算结果放在静态结构中,并返回一个指向这个结构的指针。在多线程中一个线程调用的结构可能被另一个线程覆盖。可以通过重写函数和加锁拷贝技术来消除。加锁拷贝技术指在每个位置对互斥锁加锁,调用线程不安全函数,动态的为结果分配存储器,拷贝函数返回的结构,然后解锁。

    第4类:调用线程不安全函数的函数

    线程不安全函数线程不安全 类unix线程安全版本
    rand2rand_r
    strtok2strtok_r
    asctime3asctime_r
    gethostbyaddr3gethostbyaddr_r
    geyhostbyname3geyhostbyname_r
    inet_ntoa3
    localtime3localtime_r

    在编写线程安全函数时,要注意两点:
    1、减少对临界资源的依赖,尽量避免访问全局变量,静态变量或其它共享资源,如果必须要使用共享资源,所有使用到的地方必须要进行互斥锁 (Mutex) 保护;
    2、线程安全的函数所调用到的函数也应该是线程安全的,如果所调用的函数不是线程安全的,那么这些函数也必须被互斥锁 (Mutex) 保护;

    展开全文
  • 什么是线程安全

    万次阅读 2019-01-06 21:11:21
    java中的线程安全是什么:  就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程...
  • 线程安全:就是当多线程访问时,采用了加锁的机制;即当一个线程访问该类的某个数据时,会对这个数据进行保护,其他线程不能对其访问,直到该线程读取完之后,其他线程才可以使用。防止出现数据不一致或者数据被污染...
  • Java多线程——什么是线程安全和线程不安全

    万次阅读 多人点赞 2016-08-09 14:39:33
    线程安全 就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全 就是不提供数据...
  • 什么是线程安全 什么是线程不安全

    万次阅读 2018-02-26 14:24:35
    之前在看数据数据结构 一直都有“线程安全或线程不安全的字眼”,之前一直不是很理解,今天在这里做个小结。线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能...
  • 为什么StringBuilder是线程不安全的 为什么StringBuffer是线程安全
  • 线程安全

    万次阅读 2017-04-12 11:49:42
    *线程安全就是当多个线程访问某一个类(对象或方法)时,这个对象始终都能表现出正确的行为,那么这个类(对象或方法)就是线程安全的。2.举例说明public class MyThread extends Thread{ private int count = 5 ; ...
  • java中哪些集合是线程安全的,哪些是线程不安全的

    万次阅读 多人点赞 2019-05-09 11:41:42
    线程安全和线程不安全的集合3. 如何综合考虑线程不安全和效率低的问题 1. 常见集合 这里自己总结了一些比较常见的java集合,对于这些集合的特点和区别后期博客中会进行总结介绍: 2.什么叫“集合是线程不安全的” ...
  • 1.什么是线程安全问题 就是 多线程环境中 , 且存在数据共享 , 一个线程访问的共享 数据被其他线程修改了, 那么就发生了线程安全问题 , 整个访问过程中 , 无一共享的数据被其他线程修改了 就是线程安全的 程序中如果...
  • 什么是线程安全与非线程安全线程安全就是在多线程环境下也不会出现数据不一致,而非线程安全就有可能出现数据不一致的情况。 线程安全由于要确保数据的一致性,所以对资源的读写进行了控制,换句话说增加了...
  • 什么是线程安全和线程不安全

    千次阅读 2019-12-02 16:57:42
    1、线程安全: 指多个线程在执行同一段代码的时候采用加锁机制,使每次的执行结果和单线程执行的结果都是一样的,不存在执行程序时出现意外结果。 2、线程不安全: 是指不提供加锁机制保护,有可能出现多个线程...
  • 什么叫做线程安全 HashMap Hashtable Collections.synchronizedMap()
  • 线程安全与线程不安全

    千次阅读 2017-04-27 21:22:59
    线程安全:就是多线程环境中有对全局变量的变动时,需要对执行的代码块采用锁机制,当一个线程访问到某个数据时,其他线程需要等待当前线程执行完该代码块才可执行,不会出现数据不一致或者数据被污染。 如果一段...
  • 如何解决线程安全问题

    万次阅读 2021-03-11 11:14:03
    如何解决线程安全问题 怎么解决线程的安全问题呢? 基本上所有解决线程安全问题的方式都是采用“序列化临界资源访问”的方式,即在同一时刻只有一个线程操作临界资源,操作完了才能让其他线程进行操作,也称作同步...
  • Java线程(一):线程安全与不安全

    万次阅读 多人点赞 2012-04-02 12:13:29
    作为一个Java web开发人员,很少也不需要去处理线程,因为服务器已经帮我们处理好了。记得大一刚学Java的时候,老师带着我们做了一个局域网聊天室,用到了AWT、Socket、多线程、I/O,编写的客户端和服务器,当时做...
  • 问题描述 Java BlockingQueue 阻塞队列的take()和put()方法是线程安全的吗? 多线程下调用take()或者put()方法会出问题吗? 看了BlockingQueue的三个实现类, 发现对应的方法中都使用了锁, 所以不会出现线程安全问题 ...
  • ConcurrentHashMap是如何实现线程安全

    万次阅读 多人点赞 2019-05-25 18:08:40
    文章目录ConcurrentHashMap是如何实现线程安全的前言相关概念Amdahl定律初始化数据结构时的线程安全总结put操作的线程安全总结扩容操作的线程安全扩容时的get操作多线程协助扩容在什么情况下会进行扩容操作?...
  • 文章目录目录线程安全与线程非安全C 语言的线程非安全函数(不可重入函数) 线程安全与线程非安全 多线程程序中,线程安全是必须要考虑的因素。 线程安全(Thread Safe)就是在多线程环境中,多个线程在同一时刻对同...
  • 哪些集合类是线程安全

    万次阅读 2019-05-06 16:43:48
    哪些集合类是线程安全的? Vector Stack Hashtable java.util.concurrent包下所有的集合类 ArrayBlockingQueue、ConcurrentHashMap、ConcurrentLinkedQueue、ConcurrentLinkedDeque... 【Java面试题与...
  • 同步锁-线程安全问题解决方案

    万次阅读 多人点赞 2021-03-21 15:12:05
    经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象. 上节笔记点这里-进程与线程笔记 我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件: 在多线程程序中 +...
  • 如果你的代码所在的进程中有多个线程在同时运行,而这些线可能会同时运行这段代码。...很显然可以将集合分为两组,线程安全和非线程安全,Vectore是用同步方法来是实现线程安全的而和他相似的ArrayList是线程不安全的。
  • 【多线程并发编程】六 什么是线程安全

    千次阅读 多人点赞 2020-02-24 18:57:26
    在学习多线程的道路上,我们会经常看到线程安全这类词汇,面试官也经常问,本文就来说一说什么是线程安全

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 914,243
精华内容 365,697
关键字:

线程安全是啥