标签: thread-safety

有一条规则可以确定地找出可能在Java程序中具有并发访问权限的所有对象吗？我的意图是使用这样的规则,如果它存在,找出哪些Java类可能具有并发访问权限,然后保证它们是线程安全的.在检查大型Java项目时,此规则非常有用.我一直在寻找静态方法,但我不确定这是否是多个线程可以访问对象的唯一方法.

如果我只使用不可变数据类型,我的Java程序是否可以线程安全？

任何其他因素都会影响线程安全吗？

****如果能提供一个例子,我将不胜感激.谢谢!****

如何使这个线程的代码安全？

public static class Converter
{
    public static string ConvertNameToNickname(string name)
    {
        if (name.Equals("John"))
        {
            return "Johnathon";
        }

        return name;
    }
}

或者它是否已经是线程安全的,因为"name"是一个局部变量？我只是想确定如果ConvertNameToNickname被两个不同的线程调用,那么它正在评估的名称没有被其他线程踩到.

< - 编辑 - >

好吧,其中一些答案非常有用,但我仍然没有找到我想要的答案,所以让我稍微修改一下并提出同样的问题.给定一个mutable-type参数,如何使这段代码线程安全？或者甚至可能吗？如果我在整个方法体周围抛出一个锁{}(如例2所示),在我们进入lock语句块之前,是否仍然可以修改实例变量"name"？

public static class Converter
{
    public static string ConvertNameToNickname(StringBuilder name)
    {
        if (name.ToString().Equals("John"))
        {
            return "Johnathon";
        }

        return name;
    }
}

例2:

private static readonly object _lockObject = new object();

public static class Converter
{
    public static string ConvertNameToNickname(StringBuilder name)
    {
        lock(_lockObject)
        {
            if (name.ToString().Equals("John"))
            {
                return "Johnathon";
            }

            return name; …

如何控制允许线程访问对象的时间以及何时不允许该线程访问对象.

例如,如果我有下面的情况,我想确保当我在ButtonClick事件中使用objFoo做某事时,我不能从我的doSomethingWithObjFoo方法触摸objFoo.

private void button1_Click(object sender, EventArgs e) {
    // doing something with objFoo
}

private void timer1_Tick(object sender, EventArgs e) {
    Thread T = new Thread(new ThreadStart(doSomethingWithObjFoo));
    T.Start();
}

private void doSomethingWithObjFoo(){
    // doing something else with objFoo
}

课程:

public class SomeCollection
{
    public void IteratorReset()
    {
      index = -1;
    }

    public bool IteratorNext()
    {
      index++;
      return index < Count;
    }

    public int Count
    {
      get
      {
          return floatCollection.Count;
      }
    }

    public float CurrentValue
    {
      get
      {
        return floatCollection[index];
      }
    }

    public int CurrentIndex
    {
      get
      {
        return intCollection[index];
      }
    }
}

包含对"SomeCollection"的引用的类:

public class ThreadUnsafeClass
{    
    public SomeCollection CollectionObj
    {
       get
       {
           return collectionObj;
        }               
    }      
}

类ClassA,ClassB并ClassC包含迭代CollectionObj的以下循环:

for (threadUnsafeClass.CollectionObj.IteratorReset(); threadUnsafeClass.CollectionObj.IteratorNext(); …

可能重复:
具有本地静态变量的ID生成器 - 线程安全？

每次调用时,以下函数是否会返回唯一的数字？在多线程场景中怎么样？

int returnUniqueNumber()
{
  static int i = 0;
  ++i;
  return i;
}

我有一个类,其中有两个方法,一个调用一个创建并执行多个线程的类,另一个是一个事件处理程序,它处理在这些线程完成时引发的事件(然后再次调用第一个方法).

我知道处理事件的方法在引发事件的线程中运行.因此,我SyncLock一个成员变量,说明正在运行多少个线程并从中减去一个:

SyncLock Me ' GetType(me)
    _availableThreads -= 1
End SyncLock

所以我有几个问题:

主要问题:我是否应该在类中的任何地方使用SyncLock'ing _availableThreads - 即在创建线程的方法中(在创建线程时添加1)

与此问题相关的附带问题:

1. 我通常会同步SyncLock当前的实例,但我已经看到了SyncLocks类型的代码,那么同步锁定SyncLock(Current Instance)和_availableThreads？之间的区别是什么？

2. 这两者之间会有性能差异吗？并且有什么小的我可以锁定以上不影响其他任何东西 - 可能是一个单独的'挂锁'对象创建的唯一目的是锁定类中的东西？

注意:_available线程的唯一目的是控制在任何给定时间可以运行的线程数,并且线程处理可能需要数小时才能运行的作业.

码:

Public Class QManager
    Private _maxThreadCount, _availableThreads As Integer

    Public Sub New(ByVal maxThreadCount As Integer)
        Me.MaximumThreadCount = maxThreadCount
    End Sub

    Public Sub WorkThroughQueue()

        //get jobs from queue (priorities change, so call this every time)
        Dim jobQ As Queue(Of QdJobInfo) = QueueDAO.GetJobList


        //loop job queue while there are jobs and we have threads …

我有一个奇怪的同步架构,我正在寻找一个优雅的解决方案.我已经有了一个解决方案,但我不能说它的有效性,也有点难看.所以这是问题,希望有人可以帮助我.

有两组任务可以启动和运行.每个任务都有自己的线程.这两个组都从一个负责同步部分的超类扩展.为简单起见,我将这两个组称为A组和B组.

条件:

• 如果只有B组任务在运行,那么它们可以同时运行,并且它们不会相互干扰.

• 如果启动了组A任务*,则组B任务的构造函数应该失败并出现异常.即使A组任务已在运行,也可以创建任意数量的A组任务

• 在所有当前的B组任务完成之前,A组任务无法执行.(*从上面)

• 一次只能运行1个A组任务.他们必须排队.(只要先前的条件仍然适用,可以选择在运行两个A组任务之间阻止B组任务)

我相信我的方法有效但我不喜欢它的工作方式,因为它使用了许多不同的同步点,以及我在等待计数器时有一个睡眠的事实.无论如何,代码如下

public abstract class LockableTask<Params> extends AsyncTask {

private final boolean groupA;
private static Boolean locked = false;
private static final Semaphore semLock = new Semaphore(1);
private static int count = 0;

public LockableTask(boolean groupA) {
    this.groupA = groupA;
    synchronized (locked) {
        if (locked && !groupA) {
            throw new InputException("We are locked, please wait");
        }
    }
}

@Override
protected final AsyncReturn doInBackground(Params... params) {
    if (!groupA) {
        synchronized (locked) {
            count++;
        }
    } …

我有以下runnable类.

public class OnesRun implements Runnable {

    public int ones = 0;

    private int passendNumber;

    public OnesRun(int passendNumber) {
        this.passendNumber = passendNumber;
    }

    public void run() {
        if (passendNumber == 1)
            ones++;
    }

}

这个类的每个实例都应该增加ones它遇到一个的值.

在执行完所有线程后,我想ones从类外读取值.

1. 如何增加ones 线程安全性？
2. 我如何ones从这门课外访问 ？通过静态变量？或者我可以将它放入应用程序上下文中吗？

编辑:

我希望以下伪代码能使我的意图更清晰.

OnesRun.ones = getCurrentValueOnes();

while ( (number = readNumbersFromFile) != null) {
   threadPool.execute(new OnesRun(number));
}

print("Overall values of ones " + OnesRun.ones);

假设我有一个并且想要做类似下面的事情,除了我只想锁定我正在处理的特定字典条目而不是整个字典:static Dictionary<string, object>

lock(myDictionary)
{
   if(myDictionary["myKey"] == null)
   {
      myDictionary["myKey"] = new MyClass();
   }
}

如果不编写我自己的Dictionary实现,这可能吗？

谢谢,