线程安全_线程安全集合 - CSDN
线程安全 订阅
线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行,不会出现数据污染等意外情况。 展开全文
线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行,不会出现数据污染等意外情况。
信息
外文名
thread
作    用
保证各线程正常且正确的执行
中文名
线程安全
线程安全简介
多个线程访问同一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他操作,调用这个对象的行为都可以获得正确的结果,那么这个对象就是线程安全的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。线程安全问题大多是由全局变量及静态变量引起的,局部变量逃逸也可能导致线程安全问题。若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全。类要成为线程安全的,首先必须在单线程环境中有正确的行为。如果一个类实现正确(这是说它符合规格说明的另一种方式),那么没有一种对这个类的对象的操作序列(读或者写公共字段以及调用公共方法)可以让对象处于无效状态,观察到对象处于无效状态、或者违反类的任何不可变量、前置条件或者后置条件的情况。此外,一个类要成为线程安全的,在被多个线程访问时,不管运行时环境执行这些线程有什么样的时序安排或者交错,它必须仍然有如上所述的正确行为,并且在调用的代码中没有任何额外的同步。其效果就是,在所有线程看来,对于线程安全对象的操作是以固定的、全局一致的顺序发生的。正确性与线程安全性之间的关系非常类似于在描述 ACID(原子性、一致性、独立性和持久性)事务时使用的一致性与独立性之间的关系:从特定线程的角度看,由不同线程所执行的对象操作是先后(虽然顺序不定)而不是并行执行的。
收起全文
  • Java线程(一):线程安全与不安全

    万次阅读 多人点赞 2019-04-29 17:56:09
    作为一个Java web开发人员,很少也不需要去处理线程,因为服务器已经帮我们处理好了。记得大一刚学Java的时候,老师带着我们做了一个局域网聊天室,用到了AWT、Socket、多线程、I/O,编写的客户端和服务器,当时做...

            作为一个Java web开发人员,很少也不需要去处理线程,因为服务器已经帮我们处理好了。记得大一刚学Java的时候,老师带着我们做了一个局域网聊天室,用到了AWT、Socket、多线程、I/O,编写的客户端和服务器,当时做出来很兴奋,回学校给同学们演示,感觉自己好NB,呵呵,扯远了。上次在百度开发者大会上看到一个提示语,自己写的代码,6个月不看也是别人的代码,自己学的知识也同样如此,学完的知识如果不使用或者不常常回顾,那么还不是自己的知识。大学零零散散搞了不到四年的Java,我相信很多人都跟我一样,JavaSE基础没打牢,就急忙忙、兴冲冲的搞JavaEE了,然后学习一下前台开发(html、css、javascript),有可能还搞搞jquery、extjs,再然后是Struts、hibernate、spring,然后听说找工作得会linux、oracle,又去学,在这个过程中,是否迷失了,虽然学习面很广,但就像《神雕侠侣》中黄药师评价杨过,博而不精、杂而不纯,这一串下来,感觉做Java开发好难,并不是学着难,而是知识面太广了,又要精通这个,又要精通那个,这只是我迷茫时候的想法,现在我已经找到方向了。

            回归正题,当我们查看JDK API的时候,总会发现一些类说明写着,线程安全或者线程不安全,比如说StringBuilder中,有这么一句,“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步,则建议使用StringBuffer。 ”,那么下面手动创建一个线程不安全的类,然后在多线程中使用这个类,看看有什么效果。

            Count.java:

    public class Count {
        private int num;
        public void increment() {
            num++;
        }
        public int get() {
            return num;
        }
    }

            在这个类中的increment方法是累加num值,步长为1。

            ThreadTest.java:

    public class ThreadTest {
        public static void main(String[] args) {
            Count count = new Count();
            Runnable runnable = new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count.increment();
                    }
                }
            };
            List<Thread> threads = new ArrayList<>(10);
            for (int i = 0; i < 10; i++) {
                Thread thread = new Thread(runnable);
                threads.add(thread);
                thread.start();
            }
            while (true) {
                if (allThreadTerminated(threads)) {// 所有线程运行结束
                    System.out.println(count.get());
                    break;
                }
            }
        }
        private static boolean allThreadTerminated(List<Thread> threads) {
            for (Thread thread : threads) {
                if (thread.isAlive()) {
                    return false;
                }
            }
            return true;
        }
    }

            这里启动了10个线程,每个线程累加1万次,我们期望的最终结果是10万,看一下输出结果:

    95388

            在我的电脑上运行,大多数情况下都会得到一个小于10万的值,那么想要得到我们期望的结果,就需要保证Count在多线程下使用是安全的,如何保证,请看下文。

            本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/7421217,转载请注明。

    展开全文
  • 如何解决线程安全问题

    千次阅读 2019-04-26 11:19:51
    什么是线程安全问题? 当多个线程共享一个全局变量,对其做写操作时,可能会受到其他线程的干扰,从而引发线程安全问题 内置锁(synchronized) 内置锁也叫互斥锁,可以保证线程的原子性,当线程进入方法时,会自动...

    什么是线程安全问题?

    当多个线程共享一个全局变量,对其做写操作时,可能会受到其他线程的干扰,从而引发线程安全问题

    内置锁(synchronized)

    内置锁也叫互斥锁,可以保证线程的原子性,当线程进入方法时,会自动获得一个锁,一旦锁被获得,其他线程必须等待获得锁的线程执行完代码释放锁,会降低程序的执行效率

    使用方式:

    同步方法

    public synchronized void sale() {
        if (trainCount > 0) {
            System.out.println(Thread.currentThread().getName() + "出售票" + (100 - trainCount + 1) + "张票");
            trainCount --;
        }
    }
    // 非静态同步方法使用this锁
    // 静态同步方法使用当前字节码文件

    同步代码块

    private Object obj = new Object();
    ....
    public void sale() {
        // 参数为任意全局对象
        synchronized (obj) {
            if (trainCount > 0) {
                System.out.println(Thread.currentThread().getName() + "出售票" + (100 - trainCount + 1) + "张票");
                trainCount --;
            }
        }
    }

    注意事项:

    public static void main(String[] args) {
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        ThreadDemo1 threadDemo2 = new ThreadDemo1();
        Thread t1 = new Thread(threadDemo1, "窗口1");
        Thread t2 = new Thread(threadDemo2, "窗口2");
        t1.start();
        t2.start();
    }
    // 这样的话也会产生线程安全问题
    // 那是因为两个线程分别由不同的线程创建的,它们之间的变量不共享,产生了两把不同的锁
    // 解决方法是在全局变量上加上 static 关键字,静态变量存在方法区,这个类中的所有对象都共享同一个变量

    重入锁和不可重入锁

    重入锁:即获得锁的线程可以进入它拥有的锁的同步代码块

    不可重入锁:即获得锁的线程,在方法中尝试再次获得锁时,获取不到进入阻塞状态

    死锁产生的原因

    同步中嵌套同步,同步锁是一个重入锁,就很有可能发生死锁

    ThreadLocal

    为每个线程提供局部变量,解决线程安全问题

    ThreadLocal 底层采用 Map 来实现,将当前线程作为key,将值存储到这个 map 中

    class Res {
        private Integer count = 0;
        ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<Integer>() {
            @Override
            protected Integer initialValue() {
                return 0;
            }
        };
    
        public Integer getCount() {
            int count = integerThreadLocal.get() + 1;
            integerThreadLocal.set(count);
            return count;
        }
    }

    多线性特性

    什么是原子性?

    即一个或一组操作,要么全部执行,执行过程中不会被其他线程打断,要么全部不执行

    什么是可见性?

    多线程操作中一个线程修改了全局共享变量的值,其他线程能立马得到修改后的值

    什么是有序性?

    程序执行的顺序按照代码的先后顺序执行,一般来说处理器为了提高程序运行效率,可能会对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证程序最终执行结果和代码顺序执行的结果是一致的

    Java 内存模型(JMM)

    JMM 决定一个线程对一个共享变量做写操作时,能否对另一个线程可见

    主内存:共享变量

    本地内存:共享变量副本

    多线程做修改操作时,首先从主内存中拷贝一份副本到本地内存中,当线程修改本地内存的值后,首先在本地内存修改成功,然后再将修改后的结果刷新到主内存中

    Volatile

    可见性就是说一旦某个线程修改了被 Volatile 修饰的变量,其他线程能立马获取到修改后的新值,在 Java 中为了加快程序的运行效率,对一些变量的操作通常是在该线程的寄存器或者 CPU 缓存中进行的,之后才会同步到主存,而加了 Volatile 关键字后会直接读写内存

    注意:虽然该关键字能够保证可见性,但不能保证原子性

    特性:

    • 保证可见性
    • 禁止指令重排(CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理),使用Volatile 修饰的变量,赋值后多执行了一个"load addl $0x0, (%esp)"操作,这个操作相当于一个内存屏障(指令重排序时不能把后面的指令重排序到内存屏障之前的位置),只有一个CPU访问内存时,并不需要内存屏障。

    Volatile 与 Synchronized 区别:

    Volatile 虽然能保证可见性,但不能保证原子性

    Synchronized 防止多个线程执行同一块代码,影响执行效率,就性能而言,Volatile 是高于 Synchronized 的。

    但是 Volatile 是不能取代 Synchronized 的,因为 Volatile 不能保证原子性。

    重排序

    数据依赖

    如果两个操作同时操作一份变量,且这两个操作其中有一个写操作,此时这两个操作之间就存在数据依赖

    名称 代码示例 说明
    写后读 a = 1;b = a; 写一个变量之后,再读这个位置。
    写后写 a = 1;a = 2; 写一个变量之后,再写这个变量。
    读后写 a = b;b = 1; 读一个变量之后,再写这个变量

    上面三种情况,只要更改操作的执行顺序,结果就会发生改变,编译器和处理器可能会做重排序,在做重排序时会尊徐数据依赖,所以编译器和处理器不能对数据依赖的操作重排序,这里的数据依赖性仅针对单个处理器中执行的指令序列和单线程的操作,不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑

    as-if-serial语义

    不管怎么重排,结果都不能改变

    对多线程的影响

    在单线程程序中,对存在数据依赖的操作做重排序不会影响结果,因为单线程尊徐 as-if-serial 语义,但 as-if-serial 语义提到"不考虑不同处理器之间和不同线程之间的数据依赖",所以,指令重排可能会对多线程的结果产生影响

    展开全文
  • 什么是线程安全,你真的了解吗?

    万次阅读 2018-09-20 11:52:06
    我们整天说线程安全,但是你对什么是线程安全真的了解嘛?说真的,我之前真的是了解甚微,那么我们今天就来聊聊这个问题。 再说什么是线程安全之前我们先来聊聊什么是进程。   1、什么是进程? 先来看一张图 ...

    我们整天说线程安全,但是你对什么是线程安全真的了解嘛?说真的,我之前真的是了解甚微,那么我们今天就来聊聊这个问题。

    再说什么是线程安全之前我们先来聊聊什么是进程。

     

    1、什么是进程?

    先来看一张图

     

    我们看到的这些单独运行的程序就是一个独立的进程,进程之间是相互独立存在的。

    我们上面图中的QQ、酷狗播放器、电脑管家等等都是独立的进程。

     

    2、什么是线程?

    上面简单的说了一下什么是进程,进程想要执行任务需要依赖线程,换句话说就是进程中的最小执行单位就是线程,并且一个进程中至少有一个线程。

     

    3、什么是多线程?

    提到多线程这里要说两个概念,就是串行和并行,搞清楚这个我们才能更好的理解多线程。

    所谓串行其实是相对于单条线程来执行多个任务来说的,我们就拿下载文件来举个例子,我们下载多个文件,在串行中它是按照一定的顺序去进行下载的,也就是说必须等下载完A之后,才能开始下载B,它们在时间上是不可能发生重叠的。

     

    并行:下载多个文件,开启多条线程,多个文件同时进行下载,这里是严格意义上的在同一时刻发生的,并行在时间上是重叠的。

     

    了解了这两个概念之后我们再来说说什么是多线程,举个例子,我们打开腾讯管家,腾讯管家本身就是一个程序也就是说它就是一个进程,它里面有很多的功能,我们可以看下图,能查杀病毒、清理垃圾、电脑加速等众多功能,按照单线程来说,你想要清理垃圾还要病毒查杀,那么你必须先做完其中的一件事才能做下一件事,是有一个执行的顺序的,如果是多线程的话,我们其实在清理垃圾的时候还可以查杀病毒、电脑加速等等其他的操作,这个是严格意义上的同一时刻发生的,没有执行的先后顺序。

     

    一句话总结一下:一个进程运行时产生了多个线程。

    在了解完这个问题后,我们又需要去了解一个使用多线程不得不考虑的问题,线程安全,今天我们不说如何保证一个线程的安全,我们聊聊什么是线程安全?因为我之前面试被问到了,说真的,我之前真的不是特别了解这个问题,我们好像只学如何确保一个线程安全,却不知道所谓的安全到底是什么!

     

    4、什么是线程安全?

    既然是线程安全问题,那么毫无疑问所有的隐患都是出现在多个线程访问的情况下产生的,也就是我们要确保在多条线程访问的时候,我们的程序还能按照我们预期的行为去执行,我们看一下下面的代码。

    Integer count = 0;
       
       public void getCount() {
           
           count ++;
           System.out.println(count);
       }

    很简单的一段代码,我们就来统计一下这个方法的访问次数,多个线程同时访问会不会出现什么问题,我开启的3条线程每个线程循环10次,得到以下结果

    我们可以看到,这里出现了两个26,为什么会出现这种情况,出现这种情况显然表明我们这个方法根本就不是线程安全的,出现这种问题的原因有很多,我们说最常见的一种,就是我们A线程在进入方法后,拿到了count的值,刚把这个值读取出来还没有改变count的值的时候,结果线程B也进来的,那么导致线程A和线程B拿到的count值是一样的。

     

    那么由此我们可以了解这确实不是一个线程安全的类,因为他们都需要操作这个共享的变量,其实要对线程安全问题给出一个明确的定义还是蛮复杂的,我们根据我们这个程序来总结下什么是线程安全。

     

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

     

    那么你知道有哪些方法可以保证线程安全吗?

     

    既然存在线程安全的问题,那么肯定得想办法解决这个问题,怎么解决?我们说说常见的几种方式。

    1、synchronized

    synchronized关键字,就是用来控制线程同步的,保证我们的线程在多线程环境下,不被多个线程同时执行,确保我们数据的完整性,使用方法一般是加在方法上。

     

    public class ThreadDemo {
      int count = 0; // 记录方法的命中次数
      public synchronized void threadMethod(int j) {
          count++ ;
          int i = 1;
          j = j + i;
      }
    }

     

     

    这样就可以确保我们的线程同步了,同时这里需要注意一个大家平时忽略的问题,首先synchronized锁的是括号里的对象,而不是代码,其次,对于非静态的synchronized方法,锁的是对象本身也就是this。

    当synchronized锁住一个对象之后,别的线程如果想要获取锁对象,那么就必须等这个线程执行完释放锁对象之后才可以,否则一直处于等待状态。

    注意点:虽然加synchronized关键字,可以让我们的线程变得安全,但是我们在用的时候,也要注意缩小synchronized的使用范围,如果随意使用时很影响程序的性能,别的对象想拿到锁,结果你没用锁还一直把锁占用,这样就有点浪费资源。

    2、Lock

    先来说说它跟synchronized有什么区别吧,Lock是在Java1.6被引入进来的,Lock的引入让锁有了可操作性,什么意思?就是我们在需要的时候去手动的获取锁和释放锁,甚至我们还可以中断获取以及超时获取的同步特性,但是从使用上说Lock明显没有synchronized使用起来方便快捷。我们先来看下一般是如何使用的:

     

    private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子类
      private void method(Thread thread){
          lock.lock(); // 获取锁对象
          try {
              System.out.println("线程名:"+thread.getName() + "获得了锁");
              // Thread.sleep(2000);
          }catch(Exception e){
              e.printStackTrace();
          } finally {
              System.out.println("线程名:"+thread.getName() + "释放了锁");
              lock.unlock(); // 释放锁对象
          }
    }

     

     

    进入方法我们首先要获取到锁,然后去执行我们业务代码,这里跟synchronized不同的是,Lock获取的所对象需要我们亲自去进行释放,为了防止我们代码出现异常,所以我们的释放锁操作放在finally中,因为finally中的代码无论如何都是会执行的。

    写个主方法,开启两个线程测试一下我们的程序是否正常:

     

    public static void main(String[] args) {
          LockTest lockTest = new LockTest();

          // 线程1
          Thread t1 = new Thread(new Runnable() {

              @Override
              public void run() {
                  // Thread.currentThread()  返回当前线程的引用
                  lockTest.method(Thread.currentThread());
              }
          }, "t1");

          // 线程2
          Thread t2 = new Thread(new Runnable() {

              @Override
              public void run() {
                  lockTest.method(Thread.currentThread());
              }
          }, "t2");

          t1.start();
          t2.start();
      }

     

     

    结果:

     

     

    可以看出我们的执行,是没有任何问题的。

    其实在Lock还有几种获取锁的方式,我们这里再说一种,就是tryLock()这个方法跟Lock()是有区别的,Lock在获取锁的时候,如果拿不到锁,就一直处于等待状态,直到拿到锁,但是tryLock()却不是这样的,tryLock是有一个Boolean的返回值的,如果没有拿到锁,直接返回false,停止等待,它不会像Lock()那样去一直等待获取锁。

    我们来看下代码:

     

    private void method(Thread thread){
          // lock.lock(); // 获取锁对象
          if (lock.tryLock()) {
              try {
                  System.out.println("线程名:"+thread.getName() + "获得了锁");
                  // Thread.sleep(2000);
              }catch(Exception e){
                  e.printStackTrace();
              } finally {
                  System.out.println("线程名:"+thread.getName() + "释放了锁");
                  lock.unlock(); // 释放锁对象
              }
          }
      }

     

    结果:我们继续使用刚才的两个线程进行测试可以发现,在线程t1获取到锁之后,线程t2立马进来,然后发现锁已经被占用,那么这个时候它也不在继续等待。

     

     

    似乎这种方法,感觉不是很完美,如果我第一个线程,拿到锁的时间,比第二个线程进来的时间还要长,是不是也拿不到锁对象?

    那我能不能,用一中方式来控制一下,让后面等待的线程,可以等待5秒,如果5秒之后,还获取不到锁,那么就停止等,其实tryLock()是可以进行设置等待的相应时间的。

     

    private void method(Thread thread) throws InterruptedException {
          // lock.lock(); // 获取锁对象

          // 如果2秒内获取不到锁对象,那就不再等待
          if (lock.tryLock(2,TimeUnit.SECONDS)) {
              try {
                  System.out.println("线程名:"+thread.getName() + "获得了锁");

                  // 这里睡眠3秒
                  Thread.sleep(3000);
              }catch(Exception e){
                  e.printStackTrace();
              } finally {
                  System.out.println("线程名:"+thread.getName() + "释放了锁");
                  lock.unlock(); // 释放锁对象
              }
          }
    }

     

     

    结果:看上面的代码,我们可以发现,虽然我们获取锁对象的时候,可以等待2秒,但是我们线程t1在获取锁对象之后,执行任务缺花费了3秒,那么这个时候线程t2是不在等待的。

     

     

    我们再来改一下这个等待时间,改为5秒,再来看下结果:

     

    private void method(Thread thread) throws InterruptedException {
          // lock.lock(); // 获取锁对象

          // 如果5秒内获取不到锁对象,那就不再等待
          if (lock.tryLock(5,TimeUnit.SECONDS)) {
              try {
                  System.out.println("线程名:"+thread.getName() + "获得了锁");
              }catch(Exception e){
                  e.printStackTrace();
              } finally {
                  System.out.println("线程名:"+thread.getName() + "释放了锁");
                  lock.unlock(); // 释放锁对象
              }
          }
    }

     

     

    结果:这个时候我们可以看到,线程t2等到5秒获取到了锁对象,执行了任务代码。

     

     

    以上就是使用Lock,来保证我们线程安全的方式。

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

    千次阅读 2019-01-06 21:11:21
    java中的线程安全是什么:  就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程...

    java中的线程安全是什么:
          就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问
    什么叫线程安全:
         如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,
    就是线程安全的。 
      或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
      线程安全问题都是由全局变量及静态变量引起的。
      若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则就可能影响线程安全。


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

    展开全文
  • 线程安全

    2019-03-31 23:25:20
    记得今年3月份刚来杭州面试的时候,有一家公司的技术总监问了我这样一个问题,说你给我说说有哪些线程安全的类,我心里一想,呵呵,这我早都背好了,稀里哗啦说了一大堆,那你再来说说什么是线程安全,然后就GG了,...
  • 【多线程】如何保证线程安全

    万次阅读 多人点赞 2018-03-18 20:50:00
    一、线程安全等级 之前的博客中已有所提及“线程安全”问题,一般我们常说某某类是线程安全的,某某是非线程安全的。其实线程安全并不是一个“非黑即白”单项选择题。按照“线程安全”的安全程度由强到弱来排序,...
  • 5个步骤,教你瞬间明白线程和线程安全

    万次阅读 多人点赞 2018-09-03 00:22:50
    作者 |一个程序员的成长责编 | 胡巍巍记得今年3月份刚来杭州面试的时候,有一家公司的技术总监问了我这样一个问题:你来说说有哪些线程安全的类?我心里一想,这我早都背好了...
  • Java多线程总结之线程安全队列Queue

    万次阅读 2014-03-02 22:21:12
    Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQueue,非阻塞队列的典型例子是ConcurrentLinkedQueue,在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。...
  • 线程安全和线程不安全理解

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

    万次阅读 多人点赞 2013-10-18 22:41:13
    线程安全类 在集合框架中,有些类是线程安全的,这些都是jdk1.1中的出现的。在jdk1.2之后,就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类: vector:就比arraylist多了个同步化机制(线程安全),...
  • 线程安全:就是当多线程访问时,采用了加锁的机制;即当一个线程访问该类的某个数据时,会对这个数据进行保护,其他线程不能对其访问,直到该线程读取完之后,其他线程才可以使用。防止出现数据不一致或者数据被污染...
  • Java多线程——什么是线程安全和线程不安全

    万次阅读 多人点赞 2018-12-04 23:19:46
    线程安全 就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全 就是不提供数据...
  • java中的线程安全是什么: 就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问。 什么叫线程...
  • Java多线程:线程安全和非线程安全的集合对象

    万次阅读 多人点赞 2017-01-19 12:03:45
    线程安全:就是当多线程访问时,采用了加锁的机制;即当一个线程访问该类的某个数据时,会对这个数据进行保护,其他线程不能对其访问,直到该线程读取完之后,其他线程才可以使用。防止出现数据不一致或者数据被污染...
  • 最新的详细测试 https://www.cnblogs.com/shangxiaofei/p/10465031.html ... String 字符串常量 StringBuffer 字符串变量(线程安全) StringBuilder 字符串变量(非线程安全) 简要的说, String 类型...
  • 什么是线程安全与非线程安全线程安全就是在多线程环境下也不会出现数据不一致,而非线程安全就有可能出现数据不一致的情况。 线程安全由于要确保数据的一致性,所以对资源的读写进行了控制,换句话说增加了...
  • 什么是线程安全 参考: 《Java并发编程实践》中对线程安全的定义: 当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作...
  • 线程安全和线程不安全的集合3. 如何综合考虑线程不安全和效率低的问题 1. 常见集合 这里自己总结了一些比较常见的java集合,对于这些集合的特点和区别后期博客中会进行总结介绍: 2.什么叫“集合是线程不安全的” ...
  • 如果你的代码所在的进程中有多个线程在同时运行,而这些线可能会同时运行这段代码。...很显然可以将集合分为两组,线程安全和非线程安全,Vectore是用同步方法来是实现线程安全的而和他相似的ArrayList是线程不安全的。
  • hibernate和mybatis中关于sessionfactory、session的线程安全问题详解
1 2 3 4 5 ... 20
收藏数 746,430
精华内容 298,572
关键字:

线程安全