如何在谓词中使用谓词“断言”(How to use the predicate “assert” in a predicate)

 不是线程安全意味着如果多个线程同时尝试访问该对象，则某个访问可能会发生改变，并导致问题。 考虑以下： 
 
int incrementCount() {
    this.count++;
    // ... Do some other stuff
    return this.count;
}
 
 不会是线程安全的。 为什么不是？ 设想线程1访问它， count增加，然后进行一些处理。 在通过函数时，另一个线程访问它，再次增加count 。 第一个线程，它从1到2，它现在将返回时从1到3。 线程2也会看到它从1到3，所以2发生了什么？ 
 
 在这种情况下，你会想要这样的东西（请记住，这不是任何特定于语言的代码，但最接近Java，只有2个我已完成线程之一） 
 
int incrementCount() synchronized {
    this.count++;
    // ... Do some other stuff
    return this.count;
}
 
 这里的synchronized关键字将确保只要有一个线程正在访问它，就不会有其他线程可以访问它。 这意味着线程1会击中它， count从1到2，如预期的那样。 线程2在1处理时击中它，它必须等到线程1完成。 完成后，线程1得到2的返回值，然后线程2返回，并获得预期的3。 
 
 现在，一个例子与您在那里的类似，完全是线程安全的，无论如何： 
 
int incrementCount(int count) {
    count++;
    // ... Do some other stuff
    return this.count;
}
 
 由于在这里触及的唯一变量对函数来说是完全局部的，所以不存在同时访问它的两个线程可以尝试处理从另一个线程更改的数据的情况。 这将使它线程安全。 
 
 因此，为了回答这个问题，假设函数不修改特定被调用函数之外的任何东西，那么是的，该类可以被认为是线程安全的。 

Not being thread safe means that if multiple threads try to access the object at the same time, something might change from one access to the next, and cause issues. Consider the following:
 
int incrementCount() {
    this.count++;
    // ... Do some other stuff
    return this.count;
}
 
would not be thread safe. Why is it not? Imagine thread 1 accesses it, count is increased, then some processing occurs. While going through the function, another thread accesses it, increasing count again. The first thread, which had it go from, say, 1 to 2, would now have it go from 1 to 3 when it returns. Thread 2 would see it go from 1 to 3 as well, so what happened to 2?
 
In this case, you would want something like this (keeping in mind that this isn't any language-specific code, but closest to Java, one of only 2 I've done threading in)
 
int incrementCount() synchronized {
    this.count++;
    // ... Do some other stuff
    return this.count;
}
 
The synchronized keyword here would make sure that as long as one thread is accessing it, no other threads could. This would mean that thread 1 hits it, count goes from 1 to 2, as expected. Thread 2 hits it while 1 is processing, it has to wait until thread 1 is done. When it's done, thread 1 gets a return of 2, then thread 2 goes throguh, and gets the expected 3.
 
Now, an example, similar to what you have there, that would be entirely thread-safe, no matter what:
 
int incrementCount(int count) {
    count++;
    // ... Do some other stuff
    return this.count;
}
 
As the only variables being touched here are fully local to the function, there is no case where two threads accessing it at the same time could try working with data changed from the other. This would make it thread safe.
 
So, to answer the question, assuming that the functions don't modify anything outside of the specific called function, then yes, the class could be deemed to be thread-safe.