标签: thread-safety

我通过Entity Framework 4访问我的数据库.

我有一个服务器侦听端口,等待一些消息.当消息到来时,它将被转换为表行,并且应该将其插入到数据库中.但是,可以同时发送多条消息.对于每条消息,我创建一个Task(来自TPL)并异步执行它.

这些任务中的每一个都创建一个ObjectContext实例,创建相应实体类的对象(表示DB中的表),将数据插入ObjectContext,然后调用SaveChanges方法.

因此每个线程都创建了自己的ObjectContext.ObjectContext的实例是否可以影响ObjectContext的任何其他实例？这种情况会有副作用吗？

(请注意,插入的数据不会创建任何参照完整性错误).

我有一个swing类,运行Thread类来执行特定的Job.我需要在某个时刻停止正在运行的线程.所以我在线程中放置一个布尔值,当我将其设置为true时,线程将被停止.

问题是该线程需要一些时间来完成它正在进行的内部工作.

我需要阻止用户在GUI上执行任何操作,直到线程完成.我尝试了类似setEnabled(false)的东西但是应用程序冻结了,并且在线程停止之前不会更改GUI.我也尝试在另一个线程中更新GUI,但这也不起作用.

有没有办法更新GUI或使应用程序像禁用,而停止线程的延迟是finsihed.

谢谢

我在这里尝试做的是有一个共享资源,即SharedResource777.java,这个类有两个方法doIt()和setBFlag(),这两个线程获取Lock并使用线程执行方法.

代码如下,

    import java.util.concurrent.locks.*;

    class SharedResource777{
        private boolean bFLag = false;
        private Lock lockObj = new ReentrantLock();
        private Condition condition = lockObj.newCondition();

        public void doIt() {        
            try{
                lockObj.lock();         
                while(!bFLag){
                    System.out.println(" THE THREAD "+Thread.currentThread().getName());            
                    condition.wait();
                }           
            }catch(Exception e){
                System.out.println(e);
            }finally{
                lockObj.unlock();
            }           
        }

        public void setBFlag(boolean bFLag){        
            try{
                lockObj.lock(); 
                this.bFLag = bFLag;     
                System.out.println(" THE THREAD "+Thread.currentThread().getName()+" ["+this.bFLag+"]");
                condition.signal();
            }catch(Exception e){
                System.out.println(e);
            }finally{
                lockObj.unlock();
            }
        }

    }

    class MyThread620 extends Thread{

        private SharedResource777 resource;

        MyThread620(String threadName,SharedResource777 resource){
            super(threadName);
            this.resource = resource;
        } …

在我的智能设备应用程序中,我有搜索所有可发现的蓝牙设备并使用Windows Mobile 6.5连接到设备的功能.当我按下按钮搜索蓝牙设备时,UI冻结,我无法做任何其他事情.在找到所有可发现的设备之后,UI再次响应.

我知道我应该使用线程来处理这个问题.但是,我没有成功地让它发挥作用.

这是我用于搜索蓝牙设备的代码.在代码中,我有两个BindingLists.一个是DiscoverableDevices,另一个是ConnectedSEMDevices,它们分别绑定到列表框和组合框.

    private void SearchBTDevices()
    {
     // Thread thread = new Thread(new ThreadStart(delegate{
        List<BluetoothDevice> list = new List<BluetoothDevice>();
        this.discoverableDevices.Clear();  //DiscoverableDevices is binding to the form
        list.foreach(x => this.Discoverable.Add(x));
        ConnectedSEMDevices.Clear()
        list.Where(x => x.HasAuthenticated).ToList().ForEach(x => ConnectedSEMDevices.Add(x));  // ConnectedSEMDevices is binding to the Form
     // }));
     // thread.Start();
    }

当我在上面的代码中取消注释掉Thread时,它没有做任何事情,也没有找到任何设备.在我评论出该帖子之后,它就有效了.有谁知道原因？我想以与搜索设备相同的形式执行其他操作.

我有这个代码,现在任何人都可以回答在以下情况下锁会发生什么,考虑到cond是真的: -

for (;;) {
static mutex m;
Lock lock(m);
if (cond)
break;
... 
} 

谢谢

对于以下示例:

public Car getCar(int id){
    Car result= findCarInCache(id);
    if (result==null){
       // POINT A 
       return createCarWithId(id);
    } else {
        return result;
    }
}

public Car findCarInCache(int id){
    // Do something for find a car with this id in the cache
}

public void addToCache(Car car){
    // Add the car to the cache
}

public Car createCarWithId(int id){
    Thread.sleep(10000);
    Car result= new Car(id);
    addToCache(Car);
    return result;
}

例如,两个线程同时调用getCar(2)时出现问题.然后两个线程都到达POINT A,并生成Car#2的两个实例.如何让第二个线程在POINT A等待,直到第一个线程完成创建,然后在两个调用中返回相同的对象？(我在Android中这样做)

谢谢

我是唯一这么认为的人吗？[真正的问题在一秒钟内.]

除了对它的巨大混淆,以及它与互斥或其他锁定机制的混合,当我处理线程安全情况时,我总是不得不放弃任何使用volatile,因为它根本没有做任何有用的事情.

volatile"禁止对读/写进行任何重新排序或缓存",但volatile 只要标记单个对象(并将其污染,因为它不再是"普通"对象),这并没有多大用处.

考虑一下:

Thread A            Thread B
reads vars
                    locks mutex (gets access)
locks mutex (waits)
                    writes some vars
                    releases mutex
reads vars again
releases mutex

现在,编译器可能希望优化两个线程A的读取,从而将一些结果保存在寄存器中.你说我应该宣布那些变量为volatile.我说我不想标记所有内容volatile,因为它volatile是透明的,我必须复制50%的代码才能支持volatile类型.您(他)说锁定互斥锁(至少是POSIX互斥锁)是编译器识别并正确管理的东西,要么是对库的调用(编译器无法访问),这可能会改变世界,所以编译器这样的电话会议后不会做任何事情.我说这是依赖于实现的,非常低级别的东西(我不想浏览开发文档以进行日常编程).更糟糕的是,如果由于某种原因,出于某种原因,"外部库"由于任何合法的原因而变得可供编译器访问(可能是作者在必须包含在头文件中的模板中转换函数......无论如何),它会突然改变.

所以,在我看来,volatile完全没用(和误导),除非是一些非常低级别的东西(设备读取可能,但我不能胜任这样的领域).

更好的方法是明确告诉编译器它必须放弃任何关于任何变量的假设,并且每次后续读取必须是从内存中读取的真实内容.但是我无法想象比调用虚拟外部函数更好的事情,这会产生我之前概述的相同问题.有一种优雅的方式吗？

我有这样的课.

public abstract class HtmlObject<T>
{

    public HtmlObject() {}
    public HtmlObject(string id, string name, T value)
    {
        this.ID = id;
        this.Name = name;
        this.Value = value;
    }

    public string ID { get; set; }
    public string Name { get; set; }
    public T Value { get; set; }

    public abstract string Build();
}

具体实现看起来像这样.

public class HtmlRadio : HtmlObject<string>
{
    private const string RadioHtml = "<input type='radio' name='{0}' value='{1}' {2} />{1}<br />";

    public bool Checked { get; set; }

    public …

有许多库和API(例如Qt)似乎是故意设计为非线程安全的.这种设计的动机是什么？

目前我正在使用LinkedList添加所有Command信息.如何使下面的List<Command>线程安全？我应该在这里使用其他选项而不是LinkedList吗？

private static List<Command> commands;

Command command = new Command();
command.setName(commandName);
command.setExecutionPercentage(Double.parseDouble(percentage));
command.setAttributeIDGet(attributeIDGet);
command.setAttributeIDSet(attributeIDSet);
command.setDataUsageCriteria(dataCriteria);
command.setUserLoggingCriteria(userLoggingCriteria);
command.setSleepTime(sleepTimeOfCommand);

我command正在通过从文本文件中读取并将其放入LinkedList of command如下所示的内容中添加以上所有内容.所以如果我有,three command那么我需要将所有这些添加three command到一些LinkedList我正在做的事情中.

commands.add(command);

如果我做下面的事情怎么办？ -

Collections.synchronizedList(commands.add(command));

或者我需要做这样的事情 -

commands = Collections.synchronizedList(new LinkedList<Command>());

更新: -

根据你的建议,如果我正在使用 -

private static Queue<Command> commands;


commands = new ConcurrentLinkedQueue<Command>(); // Using linked list to ensure iteration order



Command command = new Command();
command.setName(commandName);
command.setExecutionPercentage(Double.parseDouble(percentage));
command.setAttributeIDGet(attributeIDGet);
command.setAttributeIDSet(attributeIDSet);
command.setDataUsageCriteria(dataCriteria); …