精华内容
下载资源
问答
  • 什么在Java中没有其他类型的线程安全方法?“原子”是什么意思?当方法调用似乎立即生效时,该方法就是原子的。 因此,其他线程在方法调用之前或之后只能看到状态,而没有中间状态。 让我们看一下非原子方法,看...

    “线程安全”实际上意味着什么?

    通过优锐课的学习分享,讨论了关于Java中的线程安全性意味着类的方法是原子的或静态的。 那么原子是什么,静止是什么意思呢? 为什么在Java中没有其他类型的线程安全方法?

    “原子”是什么意思?

    当方法调用似乎立即生效时,该方法就是原子的。 因此,其他线程在方法调用之前或之后只能看到状态,而没有中间状态。 让我们看一下非原子方法,看看原子方法如何使类具有线程安全性。

    public class UniqueIdNotAtomic {

    private volatile long counter = 0;

    public long nextId() {

    return counter++;

    }

    }

    类UniqueIdNotAtomic通过使用易失性变量计数器创建唯一的ID。 我在第2行使用了volatile字段,以确保线程始终看到当前值,如此处更详细的说明。 要查看此类是否是线程安全的,我们使用以下测试:

    public class TestUniqueIdNotAtomic {

    private final UniqueIdNotAtomic uniqueId = new UniqueIdNotAtomic();

    private long firstId;

    private long secondId;

    private void updateFirstId() {

    firstId = uniqueId.nextId();

    }

    private void updateSecondId() {

    secondId = uniqueId.nextId();

    }

    @Test

    public void testUniqueId() throws InterruptedException {

    try (AllInterleavings allInterleavings =

    new AllInterleavings("TestUniqueIdNotAtomic");) {

    while(allInterleavings.hasNext()) {

    Thread first = new Thread( () -> { updateFirstId(); } ) ;

    Thread second = new Thread( () -> { updateSecondId(); } ) ;

    first.start();

    second.start();

    first.join();

    second.join();

    assertTrue( firstId != secondId );

    }

    }

    }

    }

    为了测试计数器是否是线程安全的,我们需要在第16和17行中创建两个线程。我们启动这两个线程(第18和19行)。然后,我们等待直到两个线程都通过第20和21行结束。 在两个线程都停止之后,我们检查两个ID是否唯一,如第22行所示。

    为了测试所有线程交织,我们使用来自vmlens第15行的AllInterleavings类,将完整的测试放在while循环中迭代所有线程交织。

    运行测试,我们看到以下错误:

    java.lang.AssertionError:

    at org.junit.Assert.fail(Assert.java:91)

    at org.junit.Assert.assertTrue(Assert.java:43)

    发生该错误的原因是,由于操作++不是原子操作,因此两个线程可以覆盖另一个线程的结果。 我们可以在vmlens的报告中看到这一点:

    在发生错误的情况下,两个线程首先并行读取变量计数器。 然后,两个都创建相同的ID。 为了解决这个问题,我们通过使用同步块使方法原子化:

    private final Object LOCK = new Object();

    public long nextId() {

    synchronized(LOCK) {

    return counter++;

    }

    }

    现在,该方法是原子的。 同步块可确保其他线程无法看到该方法的中间状态。

    不访问共享状态的方法是自动原子的。 具有只读状态的类也是如此。 因此,无状态和不可变的类是实现线程安全类的简便方法。 他们所有的方法都是自动的。

    并非原子方法的所有用法都是自动线程安全的。 将多个原子方法组合为相同的值通常会导致争用条件。 让我们看看从ConcurrentHashMap获取和放置的原子方法以了解原因。 当以前的映射不存在时,让我们使用这些方法在映射中插入一个值:

    public class TestUpdateTwoAtomicMethods {

    public void update(ConcurrentHashMap map) {

    Integer result = map.get(1);

    if( result == null ) {

    map.put(1, 1);

    }

    else {

    map.put(1, result + 1 );

    }

    }

    @Test

    public void testUpdate() throws InterruptedException {

    try (AllInterleavings allInterleavings =

    new AllInterleavings("TestUpdateTwoAtomicMethods");) {

    while(allInterleavings.hasNext()) {

    final ConcurrentHashMap map =

    new ConcurrentHashMap();

    Thread first = new Thread( () -> { update(map); } ) ;

    Thread second = new Thread( () -> { update(map); } ) ;

    first.start();

    second.start();

    first.join();

    second.join();

    assertEquals( 2 , map.get(1).intValue() );

    }

    }

    }

    }

    该测试与先前的测试相似。 再次,我们使用两个线程来测试我们的方法是否是线程安全的(第18行和第19行)。再次,我们在两个线程完成之后测试结果是否正确(第24行)。运行测试,我们看到以下错误:

    java.lang.AssertionError: expected:<2> but was:<1>

    at org.junit.Assert.fail(Assert.java:91)

    at org.junit.Assert.failNotEquals(Assert.java:645)

    该错误的原因是,两种原子方法get和put的组合不是原子的。 因此,两个线程可以覆盖另一个线程的结果。 我们可以在vmlens的报告中看到这一点:

    在发生错误的情况下,两个线程首先并行获取值。 然后,两个都创建相同的值并将其放入地图中。 要解决这种竞争状况,我们需要使用一种方法而不是两种方法。 在我们的例子中,我们可以使用单个方法而不是两个方法get和put来进行计算:

    public void update() {

    map.compute(1, (key, value) -> {

    if (value == null) {

    return 1;

    }

    return value + 1;

    });

    }

    因为方法计算是原子的,所以这解决了竞争条件。 虽然对ConcurrentHashMap的相同元素进行的所有操作都是原子操作,但对整个地图(如大小)进行操作的操作都是静态的。 因此,让我们看看静态意味着什么。

    “静止”是什么意思?

    静态意味着当我们调用静态方法时,我们需要确保当前没有其他方法在运行。 下面的示例显示如何使用ConcurrentHashMap的静态方法大小:

    ConcurrentHashMap map =

    new ConcurrentHashMap();

    Thread first = new Thread(() -> { map.put(1,1);});

    Thread second = new Thread(() -> { map.put(2,2);});

    first.start();

    second.start();

    first.join();

    second.join();

    assertEquals( 2 , map.size());

    通过等待直到所有线程都使用线程连接完成为止,当我们调用方法大小时,我们确保没有其他线程正在访问ConcurrentHashMap。

    方法大小使用在java.util.concurrent.atomic.LongAdder,LongAccumulator,DoubleAdder和DoubleAccumulator类中也使用的一种机制来避免争用。 与其使用单个变量存储当前大小,不如使用数组。 不同的线程更新数组的不同部分,从而避免争用。 该算法在Striped64的Java文档中有更详细的说明。

    静态类和静态方法对于收集竞争激烈的统计数据很有用。 收集数据后,可以使用一个线程来评估收集的统计信息。

    为什么在Java中没有其他线程安全方法?

    在理论计算机科学中,线程安全性意味着数据结构满足正确性标准。 最常用的正确性标准是可线性化的,这意味着数据结构的方法是原子的。

    对于常见的数据结构,存在可证明的线性化并发数据结构,请参见Maurice Herlihy和Nir Shavit撰写的《多处理器编程的艺术》一书。 但是要使数据结构线性化,需要使用比较和交换之类的昂贵同步机制,请参阅论文《定律:无法消除并发算法中的昂贵同步》以了解更多信息。

    因此,研究了其他正确性标准(例如静态)。 因此,我认为问题不在于“为什么Java中没有其他类型的线程安全方法?” 但是,Java何时将提供其他类型的线程安全性?

    结论

    Java中的线程安全性意味着类的方法是原子的或静态的。 当方法调用似乎立即生效时,该方法就是原子的。 静态意味着当我们调用静态方法时,我们需要确保当前没有其他方法在运行。

    目前,静态方法仅用于收集统计信息,例如ConcurrentHashMap的大小。 对于所有其他用例,使用原子方法。 让我们拭目以待,未来是否会带来更多类型的线程安全方法。

    文章写道这里,如有不足之处,欢迎补充评论。

    如果你对java技术很感兴趣也可以一起交流学习,共同学习进步!

    2496cb43573163e906a5393dd99f4179.png

    最近get了很多新知识,希望能帮到大家。需要详细的java架构思维导图路线也可以评论获取!

    展开全文
  • 状态对象(Stateful Bean),就是有实例变量的对象,可以保存数据,是非线程安全的。在不同方法调用间不保留任何状态。无状态就是一次操作,不能保存数据。无状态对象(Stateless Bean),就是没有实例变量的对象.不能...

    基本概念: 

    有状态就是有数据存储功能。有状态对象(Stateful Bean),就是有实例变量的对象 ,可以保存数据,是非线程安全的。在不同方法调用间不保留任何状态。

    无状态就是一次操作,不能保存数据。无状态对象(Stateless Bean),就是没有实例变量的对象 .不能保存数据,是不变类,是线程安全的。

    代码更好理解:

    Java代码

    1.   

    2. public   class  StatefulBean {   

    3.   

    4.      public   int  state;   

    5.      // 由于多线程环境下,user是引用对象,是非线程安全的   

    6.      public  User user;   

    7.   

    8.      public   int  getState() {   

    9.          return  state;   

    10.     }   

    11.   

    12.      public   void  setState( int  state) {   

    13.          this .state = state;   

    14.     }   

    15.   

    16.      public  User getUser() {   

    17.          return  user;   

    18.     }   

    19.   

    20.      public   void  setUser(User user) {   

    21.          this .user = user;   

    22.     }   

    23. }   

    24.   

    25.   

    26. public   class  StatelessBeanService {   

    27.   

    28.      // 虽然有billDao属性,但billDao是没有状态信息的,是Stateless Bean.   

    29.     BillDao billDao;   

    30.   

    31.      public  BillDao getBillDao() {   

    32.          return  billDao;   

    33.     }   

    34.   

    35.      public   void  setBillDao(BillDao billDao) {   

    36.          this .billDao = billDao;   

    37.     }   

    38.   

    39.      public  List<User> findUser(String Id) {   

    40. return   null ;   

    41.     }   

    42. }  


    单例模式中的有状态和无状态: 
    单例类可以是有状态的(stateful),一个有状态的单例对象一般也是可变(mutable)单例对象 。 有状态的可变的单例对象常常当做状态库(repositary)使用。比如一个单例对象TaskCache(Spring中配为singleton)可以 持有一个AtomicLong类型的属性,用来给一个系统提供一个数值惟一的序列号码,作为任务通迅管理的ID生成器。同时,一个单例类也可以持有一个聚 集,从而允许存储多个状态,如示例中的ExpiringMap缓存任务列表。
    代码示例:

    Java代码

    1. import  java.util.concurrent.atomic.AtomicLong;   

    2.   

    3. import  org.apache.mina.util.ExpiringMap;   

    4.   

    5.   

    6. public   class  TaskCache {   

    7.   

    8.      // 请求超时   

    9.      private   short  requestTimeout;   

    10.   

    11.      // 这个缓存Map是线程安全,并且有定时超时功能   

    12.      private  ExpiringMap<String, Object> tasksMap =  new  ExpiringMap<String, Object>();   

    13.   

    14.      // 线程安全的原子类,示例有状态的单例类   

    15.      private   static  AtomicLong seqNo =  new  AtomicLong( 1 );   

    16.   

    17.      // 示例有状态的单例类   

    18.      public  Long nextSeqNo() {   

    19.          return  seqNo.getAndIncrement();   

    20.     }   

    21.   

    22.      public   void  setRequestTimeout( short  requestTimeout) {   

    23.          this .requestTimeout = requestTimeout;   

    24.     }   

    25.   

    26.      // 启动过期检测   

    27.      public   void  startExpiring() {   

    28.         tasksMap.getExpirer().setTimeToLive(requestTimeout);   

    29.         tasksMap.getExpirer().startExpiringIfNotStarted();   

    30.     }   

    31.   

    32.      // 停止过期检测   

    33.      public   void  stopExpiring() {   

    34.         tasksMap.getExpirer().stopExpiring();   

    35.     }   

    36.   

    37.      // 取任务列表.   

    38.      public  Object getTasks(String key) {   

    39.          return  tasksMap.get(key);   

    40.     }   

    41.   

    42.      // 去除任务列表.   

    43.      public  Object removeTasks(String key) {   

    44.          return  tasksMap.remove(key);   

    45.     }   

    46.   

    47.      // 添加任务列表.   

    48.      public   void  addTasks(String key, Object value) {   

    49.         tasksMap.put(key, value);   

    50.     }   

    51. }  



    单例类也可以是没有状态的(stateless) ,仅用做提供工具性函数的对象。既然是为了提供工具性函数,也就没有必要创建多个实例,因此使用单例模式很合适。平常的单例类都是没有状态的,这里就不示例了。一个没有状态的单例类也就是不变(Immutable)单例类。关于不变模式,请参考 http://www.javaeye.com/topic/959751 

    EJB中的有状态与无状态: 

    1.Stateful session bean的每个用户都有自己的一个实例,所以两者对stateful session bean的操作不会影响对方。另外注意:如果后面需要操作某个用户的实例,你必须在客户端缓存Bean的Stub对象(JSP通常的做法是用Session缓存),这样在后面每次调用中,容器才知道要提供相同的bean实例。

    2.Stateless Session Bean不负责记录使用者状态,Stateless Session Bean一旦实例化就被加进会话池中,各个用户都可以共用。如果它有自己的属性(变量),那么这些变量就会受到所有调用它的用户的影响。

    3.从内存方面来看,Stateful Session Bean与Stateless Session Bean比较,Stateful Session Bean会消耗J2EE Server 较多的内存,然而Stateful Session Bean的优势却在于他可以维持使用者的状态。

    Spring中的有状态(Stateful)和无状态(Stateless) 

    1.通过上面的分析,相信大家已经对有状态和无状态有了一定的理解。无状态的Bean适合用不变模式,技术就是单例模式,这样可以共享实例,提高性能。有状态的Bean,多线程环境下不安全,那么适合用Prototype原型模式。Prototype: 每次对bean的请求都会创建一个新的bean实例。

    2.默认情况下,从Spring bean工厂所取得的实例为singleton(scope属性为singleton),容器只存在一个共享的bean实例。

    3.理解了两者的关系,那么scope选择的原则就很容易了:有状态的bean都使用prototype作用域,而对无状态的bean则应该使用singleton作用域。

    4.如Service层、Dao层用默认singleton就行,虽然Service类也有dao这样的属性,但dao这些类都是没有状态信息的,也就是 相当于不变(immutable)类,所以不影响。Struts2中的Action因为会有User、BizEntity这样的实例对象,是有状态信息 的,在多线程环境下是不安全的,所以Struts2默认的实现是Prototype模式。在Spring中,Struts2的Action中,scope 要配成prototype作用域。

    Servlet、Struts中的有状态和无状态: 

    1.Servlet体系结构是建立在Java多线程机制之上的,它的生命周期是由Web 容器负责的。一个Servlet类在Application中只有一个实例存在,也就是有多个线程在使用这个实例。这是单例模式的应用。无状态的单例是线 程安全的,但我们如果在Servlet里用了实例变量,那么就变成有状态了,是非线程安全的。如下面的用法就是不安全的,因为user,out都是有状态 信息的。

    Java代码

    1.   

    2. public   class  UnSafeServlet HttpServlet{   

    3.        

    4.     User user;   

    5.     PrintWriter out;   

    6.        

    7.      public   void  doGet (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{   

    8.          //do something...   

    9.     }   

    10. }  


    Out,Request,Response,Session,Config,Page,PageContext是线程安全的,Application在整个系统内被使用,所以不是线程安全的.

    2.Struts1也是基于单例模式实现,也就是只有一个Action实例供多线程使用。默认的模式是前台页面数据通过actionForm传入,在 action中的excute方法接收,这样action是无状态的,所以一般情况下Strunts1是线程安全的。如果Action中用了实例变量,那 么就变成有状态了,同样是非线程安全的。像下面这样就是线程不安全的。

    Java代码

    1.   

    2. public   class  UnSafeAction1  extends  Action {   

    3.   

    4.      // 因为Struts1是单例实现,有状态情况下,对象引用是非线程安全的   

    5.     User user;   

    6.   

    7.      public   void  execute() {   

    8.          // do something...   

    9.     }   

    10.   

    11.      public  User getUser() {   

    12.          return  user;   

    13.     }   

    14.   

    15.      public   void  setUser(User user) {   

    16.          this .user = user;   

    17.     }   

    18. }    



    3.Struts2默认的实现是Prototype模式。也就是每个请求都新生成一个Action实例,所以不存在线程安全问题。需要注意的是,如果由Spring管理action的生命周期, scope要配成prototype作用域。

    4.如何解决Servlet和Struts1的线程安全问题,当我们能比较好的理解有状态和无状态的原理,自然很容易得出结论:不要使用有状态的bean,也就是不要用实例变量 。如果用,就要用prototype模式。Struts1 user guide里有: Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables , in your Action class.

    总结: 
    Stateless无状态用单例Singleton模式,Stateful有状态就用原型Prototype模式。 
    Stateful 有状态是多线程编码的天敌,所以在开发中尽量用Stateless无状态,无状态是不变(immutable)模式的应用,有很多优点:不用管线程和同步的问题 ,如果值是不可变的,程序不用担心多个线程改变共享状态,所以可以避免线程竞争的bugs. 因为没有竞争,就不用用locks等机制,所以无状态的不变机制,也可以避免产生死锁现象。

    国外一些哥们的观点: 
    Immutable objects may not be altered after their creation. So: Yes, they are some kind of stateless.As immutable objects can not be changed, there is no need for locking - reading access to objects is always threadsafe (when not modifying variables). Therefore, real immutable objects are always threadsafe.

    Rod Johnson大叔的观点: 
    Stateless or Stateful?
    Service objects will usually be stateless. Stateless service layers are highly scalable: They pose no replication issues and there is no need to allocate additional resources for every client. (Remember that one of
    the key motivations of a middle tier is to share resources between multiple clients.) It is also much easier for stateless service layers to support remote clients, if necessary. A stateless service layer is one concession of object orientation that I find not too painful.
    此处省去N个字。
    If possible, design applications to use a stateless service layer. Hold state in the web tier, rather than in the business logic tier, if possible.


    转载于:https://my.oschina.net/moziqi/blog/346503

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

    2020-05-03 17:59:59
    JAVA并发编程提出: 当多个线程访问一个类的时候,如果不...什么是状态? 不包含域,也没有引用其他域,只包含一次瞬时状态,会唯一的存在本地,而本地变量存在栈中,只有执行线程才能访问它 无状态对象永远线程安全的 ...

    JAVA并发编程提出:
    当多个线程访问一个类的时候,如果不考虑这些线程在运行时环境的调度和交替执行,并且不需要额外的同步及在调用方代码不必作其他的协调,这个类的行为仍然是正确的,那么这个类是线程安全的;

    什么是无状态?

    不包含域,也没有引用其他域,只包含一次瞬时状态,会唯一的存在本地,而本地变量存在栈中,只有执行线程才能访问它

    无状态对象永远是线程安全的

    什么是不可变对象?

    不可变对象永远是线程安全的

    • 对象的状态不能在创建后改变
    • 所有的域都是finalll类型
    • 它被正确创建(创建期间没有this引用的逸出)
    public final class FinalNumber {
        private final int num = 1;
        private final List<Integer> nums = new ArrayList<>();
        private final String str = "123";
    
        public FinalNumber() {
            nums.add(2);
        }
    
        public int getNum() {
            return num;
        }
    
        public List<Integer> getNums() {
            return nums;
        }
    }
    
    

    反射修改final字段

     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
            FinalNumber finalNumber = new FinalNumber();
            Field str = finalNumber.getClass().getDeclaredField("str");
            str.setAccessible(true);
            System.out.println(str.getType().toString());
            Object o = str.get(finalNumber);
            
            
            System.out.println(o);
            Field value = o.getClass().getDeclaredField("value");
            value.setAccessible(true);
            char[] chars = (char[]) value.get(o);
            chars[0] = '2';
            System.out.println(o);
        }
    
    展开全文
  • 什么是线程安全

    2018-07-16 21:26:19
    在线程安全中我们关注的共享、可变的状态,也就是一个叫状态的变量。   线程安全(对类来说): 一个类同时被多个线程访问时,依然可以按这个类被设计的那样完成工作,没有偏差。或者这么说,一个类同时被多个...

    共享:

    一个变量可以被多个线程访问。

    可变:

    变量在被多个线程访问期间,其值可以被改变。

    状态:

    其实就是某个对象的一个属性。在线程安全中我们关注的是共享、可变的状态,也就是一个叫状态的变量。

     

    线程安全(对类来说):

    一个类同时被多个线程访问时,依然可以按这个类被设计的那样完成工作,没有偏差。或者这么说,一个类同时被多个线程访问时,依然像单线程的工作逻辑那样完成工作。

     

    共享的东西在存在线程安全问题,比如类级的变量。对共享变量存在修改行为时才会存在线程安全问题,只读是不存在线程安全问题的。所以避免出现线程安全问题,我们尽量要:

        不使用共享变量;

        使用共享变量,但它不可变;

        使用共享可变变量时,在对它存在修改行为的地方使用同步(让这个地方单线程工作)

    展开全文
  • 什么在Java中没有其他类型的线程安全方法?“原子”是什么意思?当方法调用似乎立即生效时,该方法就是原子的。 因此,其他线程在方法调用之前或之后只能看到状态,而没有中间状态。 让我们看一下非原子方法,看...
  • ...     基本概念: 有状态就是有数据存储功能。有状态对象(Stateful Bean),就是有实例变量的对象 ,可以保存数据,是非线程安全的。在不同方法调用间不保留任何...不能保存数据,不变类,线程安全的。...
  • 线程安全可以简单理解为一个方法或者一个实例可以在多线程环境中使用而不会出现...1.无状态的一定线程安全的。这个很好理解,因为所谓线程不安全也就是一个线程修改了状态,而另一个线程的操作依赖于这个被修改的状
  • 它的无状态是指对于事务处理没有记忆能力,缺少状态意味着后续的操作需要前面的信息。 解决办法:1,通过cookie解决,2,通过session会话保存。 转载于:https://www.cnblogs.com/jasonboren/p/11053530.html...
  • 并发编程专题七-什么是线程安全

    千次阅读 2019-06-16 16:15:33
    一、什么是类的线程安全 既然今天的主题线程安全,那什么是线程安全呢? 其实线程安全没有一个明确的定义,Doug Lea大师(不认识的去百度,java不认识的去面壁)给下的定义为多线程下使用这个类,不过多线程如何...
  • 当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在调用代码中不需要任何额外的同步或者协同,这个类都能表现出正确的行为,那么就称这个类线程安全的。 实现线程安全的...
  • 什么是安全模式?mysql安全模式什么意思?在mysql中,如果在update和delete没有加上where条件,数据将会全部修改。不只是初识mysql的开发者会遇到这个问题,工作有一定经验的工程师难免也会忘记写入where条件。为了...
  • 什么是安全模式?mysql安全模式什么意思?在mysql中,如果在update和delete没有加上where条件,数据将会全部修改。不只是初识mysql的开发者会遇到这个问题,工作有一定经验的工程师难免也会忘记写入where条件。为了...
  • 1.对方(请求方或客户端)没有收到服务器发送的[SYN,ACK]包(一般由于网络结构或安全规则限制导致(SYN,ACK)包无法发送到对方)。 2.对方收到了[SYN,ACK]包却没有ACK。 这种情况分两种可能, 一对方程序有意这么...
  • 什么是安全模式?mysql安全模式什么意思?在mysql中,如果在update和delete没有加上where条件,数据将会全部修改。不只是初识mysql的开发者会遇到这个问题,工作有一定经验的工程师难免也会忘记写入where条件。为了...
  •  安全是没有物质危险和精神恐慌而使人处于自由的状态。 2.什么叫事故? 事故是指人们在有目的地进行生产劳动中突然发生意外事件,迫使生产暂时停止或人员受到伤害。事故是生产实践异常的突变。 3.什么是劳动保护...
  •  答:安全是没有受到威胁、没有危险、危害、损失。人类的整体与生存环境资源的和谐相处,互相不伤害,不存在危险、危害的隐患, 是免除了不可接受的损害风险的状态安全是在人类生产过程中,将系统的运行状态对...
  •  安全是没有物质危险和精神恐慌而使人处于自由的状态。 2.什么叫事故? 事故是指人们在有目的地进行生产劳动中突然发生意外事件,迫使生产暂时停止或人员受到伤害。事故是生产实践异常的突变。 3.什么是劳动保护...
  • 什么情况下会有线程安全问题

    千次阅读 2017-08-21 01:12:32
    ps:有状态,无状态对象是什么概念 有状态就是有数据存储功能。有状态对象(Stateful Bean),就是有实例变量的对象 ,可以保存数据,是非线程安全的。在不同方法调用间不保留任何状态。 无状态就是一次操作,不...
  • PHP验证登录状态安全

    千次阅读 2018-07-03 09:36:03
    固定的私钥来做salt其实不好,一旦私钥泄漏之后就很麻烦,而且最痛苦的其实你不知道你到底有没有泄漏用户的密码字符串作为salt更好的办法签名字符串:$sign = md5('$user_id+$user+_password[+浏览器UA[+IP地址[....
  • 什么Java中没有其他类型的线程安全方法? “原子”是什么意思? 当方法调用显示立即生效时,方法原子的。因此,其他线程可以在方法调用之前或之后看到状态,但没有看到中间状态。让我们看一看非原子方法,看看...
  • spring在什么情况下线程不安全

    千次阅读 2018-10-26 14:36:15
    2.我们交由Spring管理的大多数对象其实都一些无状态的对象,这种不会因为多线程而导致状态被破坏的对象适合Spring的默认scope,每个单里的无状态对象都线程安全的(也就是说只要状态的对象,不管单例多例都...
  • 半个读书笔记,没什么技术含量 线程安全 当多个线程访问某个类时,不管运行时如何调度,或者线程如何交替执行,在主调代码中不需要额外...无状态对象一定线程安全的 原子性操作 一个线程,要么全部执行完,要么干...
  • windows 2008用 FileZilla Server 搭建的FTP 提示信息:530 This server does not allow plain FTP. You have to use FTP over TLS 大家有没有什么解决方案?
  • 1.对方(请求方或客户端)没有收到服务器发送的[SYN,ACK]包(一般由于网络结构或安全规则限制导致(SYN,ACK)包无法发送到对方)。 2.对方收到了[SYN,ACK]包却没有ACK。 这种情况分两种可能,一对方程序有意这么...
  • 但小伙伴们有没有想过,为什么喝水对我们如此重要?如果一直不喝水,又会对身体产生怎么样的影响呢?01喝水的重要性首先在日常生活中,饮水并不仅限于纯净水,像果汁、饮料、茶水、咖啡等等都算。这些液体饮品中,所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 716
精华内容 286
关键字:

安全是没有什么状态