标签: thread-safety

以下代码有什么问题？

private Map<Integer, Integer> aMap = new ConcurrentHashMap<Integer, Integer>();    
Record rec = records.get(id);
  if (rec == null) {
      rec = new Record(id);
      records.put(id, rec);
  }
  return rec;

1. 以上代码是不是线程安全的？putIfAbsent在这种情况下我为什么要在这里使用？
2. 锁定仅适用于更新.在检索的情况下,它允许完全并发.这句话是什么意思？

我读了jakob jenkov州的教程,

public void someMethod(){

  LocalObject localObject = new LocalObject();

  localObject.callMethod();
  method2(localObject);
}

public void method2(LocalObject localObject){
  localObject.setValue("value");
}

是线程安全的.但我觉得

public class LocalObject extends Thread {
    public void run(){
        //LocalObject a= new LocalObject();
        method2(this);
    }

    public void someMethod(){
        LocalObject localObject = new LocalObject();

        localObject.callMethod();
        method2(localObject);
    }

    public void method2(LocalObject localObject){
        localObject.setValue("value");
    }
    public void setValue(String s){

    }
    public void callMethod(){

    }
    public static void main(String args[]){
        LocalObject a= new LocalObject();
        a.start();
        a.method2(a);
    }

}

是不是线程线程安全,因为两个线程1. main …

具体答案请!我对围绕集合锁定,线程安全等的更好(最佳)实践非常熟悉.只是想要围绕这个特定场景的一些答案/想法.

我们有一些类型的遗留代码:

public class GodObject
{
    private readonly Dictionary<string, string> _signals;

    //bunch of methods accessing the dictionary

    private void SampleMethod1()
    {
        lock(_signals)
        {
            //critical code section 1
        }
    }

    public void SampleMethod2()
    {
        lock(_signals)
        {
            //critical code section 2
        }
    }
}

对字典的所有访问都在这样的锁定语句中.如果锁定没有明确起作用,我们会得到一些可以解释的错误 - 这意味着2个或更多线程可以同时访问字典.

所以我的问题是 - 有没有任何场景可以让多个线程同时访问关键部分？对我来说,它应该是不可能的,因为引用是只读的,并不是对象可能会发生变化,而且围绕lock()的大多数问题都是死锁而不是同步没有发生.但也许我错过了一些细微差别或明显的东西？

这是在长期运行的Windows服务.NET Framework 3.5中运行.

我在Windows Phone 8应用程序中有一个本地数据库.该应用程序包含对数据库的大量查询,我不希望对UI的响应性产生不良影响.

例如,我有一个用户表和方法,用于通过id从数据库中获取用户.

目前的变种

public class CacheDataContext : DataContext
{
    public static string DBConnectionString = "Data Source=isostore:/Cache.sdf";

    public CacheDataContext(string connectionString)
            : base(connectionString) { }

    public static AutoResetEvent OperationOnDatabaseUser = new AutoResetEvent(true);

    public Table<User> UserItems;
}

public class CacheDataContextUser : CacheDataContext
{
    public CacheDataContextUser(string connectionString)
        : base(connectionString) { }

    public User GetUser(string id)
    {
        try
        {
            OperationOnDatabaseUser.WaitOne();
            using (CacheDataContext context = new CacheDataContext(DBConnectionString))
            {
                //find user in the data base and return 
            }
        }
        finally
        {
            OperationOnDatabaseUser.Set();
        } …

我可以安全地IsBusy从多个线程读取实例化单例的布尔属性,而不会导致任何线程安全问题,或者我已经处于危险水域？

这可能是一个愚蠢的问题但是..让我们假设我有一个类ContainerClass,如果包含一个HashSet,它可以从几个添加并删除元素的线程访问..在其中一个线程中,让我们称之为线程1,我执行以下代码:

if(ContainerClass.hashSet.containsKey(keyId))
    int number = ContainerClass.hashSet.get(keyId);

是否保证在第二行执行时,具有键keyId的元素仍然存在？或者这个线程可以在if语句中进行检查,然后暂停,然后另一个线程改变HashSet,并且线程1获得NullPointerException？

为什么将"this"传递给Thread构造函数是一种不安全的构造技术？如果是那么替代方案是什么？它与测试或调试有关吗？我找到了一些答案,但没有完全理解.

class NewThread implements Runnable {
    Thread t;
    NewThread(){ 
        t = new Thread(this,"My new Thread");
    }
}

+=c ++中的运算符是否是线程安全的？

可以想象它不是的情况(伪代码):

int a = 5;

void thread1 () {
   a += 5;
}

void thread2 () {
   a += 5;
}

void main () {
    start_thread1 ();
    start_thread2 ();
    //Prints 15 always, but i think 10 is not impossible.
    printf ("%d\n", a);
}

很明显,当+ =重载时我必须使用互斥锁,但是在使用简单类型时我是否必须设置互斥锁？

我已经为SqlCommand编写了一个扩展方法来执行一批命令,我称之为ExecuteBatchNonQuery.这很好用.我已经更改为返回消息输出,为此我必须创建一个从InfoMessage调用的方法.它附加到一个我不得不制作静态的字符串构建器.我担心这个stringbuilder不是线程安全的.我必须使用静态,有什么方法可以让它的线程安全,还是有替代方案？

internal static class SqlCommandHelper
{
    private static readonly StringBuilder StringBuilder = new StringBuilder();

    internal static string ExecuteBatchNonQuery(this SqlCommand cmd, string sql)
    {
        SqlConnection conn = cmd.Connection;
        conn.Open();
        conn.InfoMessage += MyConnectionInfoMessage;
        string sqlBatch = string.Empty;
        sql += "\nGO"; // make sure last batch is executed.
        StringBuilder.Clear();
        try
        {
            foreach (string line in sql.Split(new string[2] { "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries))
            {
                if (line.ToUpperInvariant().Trim() == "GO")
                {
                    cmd.CommandText = sqlBatch;
                    cmd.ExecuteNonQuery();
                    sqlBatch = string.Empty;
                }
                else
                {
                    sqlBatch += line + "\n"; …

我们知道有两种方法可以在Java中创建Thread.

1. 实现Runnable接口
2. 扩展Thread类[Thread是一个具有run()方法的默认实现的具体类]

在第二种方法中,我们必须提供run()方法的实现来执行我们的线程逻辑.如果是这样,那么为什么JDK开发人员没有在Thread类中将run()方法作为抽象？

我有兴趣了解其背后的原因,为Thread Class中的run()方法提供默认实现.