标签: thread-safety

public Foo getFoo(){
    Foo foo = null;

    synchronized(fooList){
        if(fooList.size() > 0){
            foo = fooList.remove(0);
        }
    }

    return foo;
}

由于foo是在同步块之外声明的，是否存在返回错误数据的可能性？

我有一台服务器和“x”个客户端。

当服务器侦听入站连接时，它将创建一个客户端处理程序实例（管理客户端通信的类），该实例将在单独的线程中分离。

根据客户端发送到服务器的命令，服务器可能需要访问 SQL 数据库来存储有关该客户端的信息。

客户端处理程序实例将“处理”此请求。唯一的问题是，如果多个客户端处理程序想要访问 SQL 数据库来执行完全相同的操作，则可能会出现读/写问题。

我正在考虑在服务器上公开一个静态方法，从客户端句柄实例调用它，然后锁定访问 SQL 数据库的函数（读或写）。

这是一个好方法还是有更好的方法？

谢谢。

我有以下案例，

public class Test {

    private static final int MAX_NUMBER = 10_00_00;

    public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();

        long start = System.nanoTime();
        for(int i = 0; i < MAX_NUMBER; i++) {
            list.add(i * 2);
        } 
        long end = System.nanoTime();
        System.out.println(((end - start) / Math.pow(10, 9)));
    }

}

输出

6.861539857

与大约花费的时间相比，它添加元素的速度相当慢。我在文档中知道了原因，ArrayList0.004690843

一种线程安全的变体，ArrayList其中所有可变操作（添加、设置等）都是通过制作底层数组的新副本来实现的。

所以，我的理解是，每当我在此列表中添加新元素时，它都会创建新的新数组并在该数组的最后一个索引处添加元素。我发现add方法中有一个锁，除此之外，该方法实际上每次都创建新的数组。

当我增加到MAX_NUMBER我10_00_000的程序继续运行并且永远不会结束（它会，但我不能等这么久）。

我认为Collections.synchronizedList当您想要线程安全和速度时这是更好的选择。我用了它，花了大约0.007673728。

我的问题：

1. 为什么它在内部创建新数组，线程安全与此有关吗？
2. 为什么在这种情况下要花这么多时间 …

希望一个简单的问题来回答。我找不到任何绝对明确的答案。任何人都可以帮助提供可靠的消息来源。

我的普遍看法是，如果不使用适当的同步块，延迟加载在多线程应用程序中是危险的。我想知道这是否适用于 Spring。

谢谢。

我正在尝试动态锁定线程，但无论我尝试什么，总会发生某种竞争条件，这似乎是由多个线程同时启动任务引起的，但我一直无法找到一个好的答案这。

这是一个例子：

using System.Linq;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
public static readonly Object padLock = new Object();
public readonly static ConcurrentDictionary<string, object> locks = new 
ConcurrentDictionary<string, object>();
public static List<string> processes = new List<string>();

public static void Main()
{
  //Add random list of processes (just testing with one for now)
  for (var i = 0; i < 1; i++) {
     processes.Add("random" + i.ToString()); 
  }

  while (true)
  {
     foreach (var process in processes )
     {
        var currentProc = …

我有一个多线程程序，其中每个线程调用函数 erand48() 来生成随机数。每个线程都有自己的私有随机种子，因此种子不会共享。但是，erand48()正如规范中所述，它不是线程安全的。

我尝试erand48()用random()线程安全的替换，但它要慢得多，而且性能是我首先关心的问题。

我还要指出，我事先不知道生成的值的数量，因此我无法像其他博客建议的那样预先生成所有值

erand48() 是否有任何替代方案可以像它一样快并且是线程安全的？

我有两个函数，比如 foo() 和 bar()，我希望它们互斥，即在 bar() 运行时完全阻止 foo() 的运行或在 foo() 运行时完全阻止 bar() 的运行为线程安全而运行。

但是，我可能会在 foo() 内部调用 bar()，也就是说，当 foo() 在 foo() 内部调用 bar() 时，让 bar() 运行，但其他线程不会调用 bar()。

是否可以？如果是，你能提供大致的想法吗？

尝试在C中使用一个或多个互斥体，很容易使两个函数互斥，但是我不能在foo()中调用bar()，它们会进入死锁。

我不能在 foo() 内部调用 bar() 之前就解锁互斥锁，因为我不能保证下一个 bar() 运行是在 foo() 内部调用的那个。

我正在寻找一种解决方案，即 foo 将阻止 bar，如果它们在不同的线程中运行，bar 将阻止 foo。但是当 foo 在其主体内（同一线程）调用 bar 时，让 bar 运行。

谢谢

shutdown() 的 Java 文档说：

关闭

无效关闭()

启动有序关闭，其中执行先前提交的任务，但不会接受新任务。如果已经关闭，则调用不会产生任何附加效果。该方法不等待之前提交的任务完成执行。使用awaitTermination 来做到这一点。

这两种说法不是矛盾吗？（...之前提交的任务执行完毕VS不等待之前提交的任务完成执行）？

我尝试了一个示例程序shutdown()。而且它确实等待先前提交的任务完成，这与shutdownNow()！

为什么下面的代码I have shutdown true在应该等待阶乘任务完成时返回？

public class RunnableMain {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        RunnableFactorialTask runnableFactorialTask = new RunnableFactorialTask(5);
        executor.submit(runnableFactorialTask);
        executor.shutdown();
        System.out.println(" I have shutdown.."+executor.isShutdown());
    }
}

class RunnableFactorialTask implements Runnable {

    private int num = 0;

    public RunnableFactorialTask(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        int factorial = 1;
        try {
            Thread.currentThread().sleep(6000);
        } catch (InterruptedException …

Public Class Customer
{
   public int CustomerId{get;set;}
   Public string CustomerName{get;set;}
}

public class RunParallel(List<Customer> namelessCustomers)
{
   Parallel.ForEach(namelessCustomers, (customer) =>{
      var customerName = CallAPIToReturnCustomerName(customer.CustomerId);
      customer.CustomerName = customerName
   }
}

嗨是customer.CustomerName=customerName线程安全的。我想要的是更新客户列表，以便每个对象都获得客户名称。如果不是，我怎么能得到这样的工作。另外你能解释一下为什么这不是线程安全的吗？

我有一个Map<Sting, List<Object>>可以从多个 Java 类实例访问的。这Map有时会由单独的线程偶尔更新。实例永远不会写入任何对象。他们只是获取Lists 之一并读取其中的对象。

我应该为此担心线程安全吗？只有一个线程在写。