我知道i ++不是一个线程安全的操作.我也理解为什么i ++比i = i + 1更快.在线程安全方面,i = i + 1与i ++有什么不同吗？任何字节码级别的解释都非常有用.
我正在阅读一本Java书,并发现了以下问题.
在下面的代码中,类线程是否安全？
public class Queen
{
public int x;
public synchronized int getX()
{
return x;
}
public synchronized void setX(int x)
{
this.x = x;
}
public static void main(String args[])
{
}
}
我的回答是肯定的,因为只有两个方法都是同步的,所以当其中一个方法正在运行时,它会锁定对象,而另一个方法无法运行.
但是,官方答案是NO,并且解释是变量int x是public,并且可以由线程修改,而另一个线程在其中一个同步方法中.那可能吗？？同步方法是否在此处保留线程,这意味着该对象中的所有内容都包含公共变量？
我在某处读到单例是线程不安全的.我试图理解为什么会这样.如果我有一个像这样的单例对象:
class singleton final
{
public:
static singleton& instance()
{
static singleton unique;
return unique;
}
private:
singleton() = default;
singleton(singleton const&) = delete;
singleton& operator=(singleton const&) = delete;
};
如果我有这样的代码:
singleton *p1, *p2;
auto t1 = std::thread([] { p1 = &singleton::instance(); });
auto t2 = std::thread([] { p2 = &singleton::instance(); });
t1.join();
t2.join();
是否有可能p1和p2指向两个不同的singleton实例？如果unique是static,它的"静态"性质是否在完全初始化之前不会生效？如果是这样,这是否意味着可以同时访问静态对象的初始化,从而允许创建多个静态对象？
我有一个带链表的简单类:
private final LinkedList<Object> list;
如果我有两个方法来操作此列表:
public void m1(){ ... list.poll()...}
public void m2(){...list.clear)....}
我如何确定ThreadSafety？两种方法都接收"synchronized"关键字是否足够,或者我需要放置一个
synchronized(list){
System.out.println("locking on :" + lock);
}
围绕方法代码？
常识告诉我它是第二个,但我想要确认,或者更简单的方法来确保我的列表不会搞砸.
PS:或者这会更好地放在CodeReview中？不知怎的,这里的感觉更加到位.
如果下面的代码是线程安全的,有人可以向我澄清一下吗？
int get_time(uint64_t *time)
{
struct timespec spec;
if (!time)
return -EFAULT;
if (clock_gettime(CLOCK_REALTIME, &spec) == -1)
return -errno;
*time = //convert timespec into nanoseconds
return SUCCESS;
}
这是一个可以由多个线程调用的库中的API.规范是一个局部变量,所以它不应该是一个问题.正确？我的疑问是关于clock_getime(POSIX.1-2001)和time参数的赋值.我想介绍一个互斥锁,但我不确定它是否是严格要求的.
到处都注意到VCL不是线程安全的,我们必须同步访问它.所以它的VCL错误不是线程安全的.
VCL本身如何是线程安全的？
我需要做一些要求读取线程中arrey的每个元素的东西.每个线程只需要阅读元素[i]做i++.我需要锁i++吗？
我在某处读到带有双变量的异步操作需要锁定以防止意外结果.我怎么能对另一个操作说同样的话？以下是有问题的操作列表？
有关更多细节.我有全局变量:
public static int[] IntArray;
public static int ArrayPointer = 0;
我以这种方式在池中启动一些线程:
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadMethod));
像这样:
static void ThreadMethod() {
//loop until ArrayPointer is too big
Console.WriteLine(IntArray[ArrayPointer]);
ArrayPointer++;
//end of loop
}
我正在阅读本教程.我理解volatile关键字的用法.但是当我试图在不使用volatile关键字的情况下在同步块中对关注变量进行操作时实现相同的结果时,它不起作用.它抛出IllegalMonitorStateException.这是我试过的修改过的代码.
public class VolatileTest {
private static Integer MY_INT = 0;
public static void main(String[] args) {
new ChangeListener().start();
new ChangeMaker().start();
}
static class ChangeListener extends Thread {
@Override
public void run() {
synchronized(MY_INT){
int local_value = MY_INT;
while ( local_value < 5){
if( local_value!= MY_INT){
System.out.format("Got Change for MY_INT : {0}", MY_INT);
local_value= MY_INT;
try {
MY_INT.wait();
} catch (Exception e) { e.printStackTrace(); }}
}
}
}
}
static class ChangeMaker extends Thread{
@Override
public void run() …请考虑以下代码：
void h(M m2)
{
...
}
int main()
{
while (true) {
M m1 = ...;
std::thread t(h, std::move(m1));
t.detach();
}
}
是否可以保证-d从之前构造的m2正确被销毁？还是有种族？movem1m1
我有一个写入原子变量的线程.(使用memory_order_release).线程A.
还有许多其他线程可以从该变量中读取.(使用memory_order_acquire).线程B.
在线程A中,使用memory_order_relaxed读取该变量是否安全？