1

我希望你们一切都好。所以来到这个问题。我有这部分代码:

private static ArrayList<String> primelist = new ArrayList<>();
static void addToList(String list_elm) {
    primelist.add(list_elm);
}

基本上,我在完整代码(如下)中创建的多个线程同时访问此列表,这些线程负责进行一些计算并返回结果,然后primelist通过调用方法将其添加到此列表中addToList(String list_elm)

但是,在所有线程都被终止(即:完成它们的工作)之后,在primelist. 因此,经过一番研究,事实证明 ArrayList 不是线程安全的类,因此它的方法也不是。我想问以下(也许很深)问题:

线程在执行一行代码时是否会被放入(等待//定时等待)..,也就是说它正在调用该方法addToList(String list_elm)并且它到达了该行primelist.add(list_elm);但是在添加元素时它恰好停止了!

如果不能,请澄清我对(尤其是)ArrayList 案例的困惑。((基本上是怎么回事?^^))

完整代码:

    import java.util.ArrayList;    
    import java.util.Iterator;

    public class CreatingAThreadThree
    {
    private static ArrayList<String> primelist = new ArrayList<>();
    static void addToList(String list_elm)
    {
        primelist.add(list_elm);
    }
    static ArrayList<String> getListReference(){
        return primelist;
    } 
    public static void main(String[] args)
    {
        for(long x = 6223372036854775899L; x<=(6223372036854775999L); x+=2)
        {
            new Thread (new MyCalcRunnable(x)).start();             
        }
        for(long x = 9223372036854774703L; x<=9223372036854774789L; x+=2 )
        {
            new MyCalcThread(x, "myChildThread"+x);             
        }

        Thread mainThread = Thread.currentThread();
        int spinner =0;
        char animation = ' ';
        System.out.println("Total number of active threads: " + Thread.activeCount());
        System.out.print("Calculating primes: ");
        while(Thread.activeCount()   >1)
        {
            spinner ++;
            switch(spinner)
            {
            case 1:
                animation = '|';
                break;
            case 2:
                animation = '/';
                break;
            case 3:
                animation = '-';
                break;
            case 4:
                animation = '\\';
                spinner = 0;
                break;
            }
            System.out.print("\b" + animation);
            try
            {
                Thread.sleep(200);
            }catch(InterruptedException ex)
            {
            }           
        }
        System.out.println("Total number of active threads: " + Thread.activeCount());
        System.out.println("Results List:");
        Iterator<?> iterator = (getListReference().iterator());
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }
    }

    class MyCalcThread extends Thread
    {
    private long numberToFactor = 0;
    MyCalcThread(long numberToFactor, String name)
    {
        super(name);
        this.numberToFactor = numberToFactor;
        start();
    }

    @Override
    public void run()
    {
        CreatingAThreadThree.addToList(new PrimeStuff().isItPrime(this.numberToFactor));
    }
    }

    class MyCalcRunnable implements Runnable
    {
    private long numberToFactor = 0;
    MyCalcRunnable(long numberToFactor)
    {
        this.numberToFactor = numberToFactor;   
    }
    @Override
    public void run()
    {
    CreatingAThreadThree.addToList(new PrimeStuff().isItPrime(this.numberToFactor));
    }
    }

    class PrimeStuff
    {
    String isItPrime(long numberToFactor)
    {
        if(numberToFactor % 2 == 0)         
            return (numberToFactor +"is Not prime....divisible by 2");

        long squareRoot = (long)(Math.sqrt(numberToFactor));
        for(long i=3; i<squareRoot; i++)
        {
            if(numberToFactor % i == 0)
            {
                return (numberToFactor +"is Not prime....first divisible by " +                  i);    
            }
        }
        return (numberToFactor + " is Prime!!");
    }
    }
4

2 回答 2

1

你专注于错误的问题;含义:花时间修复损坏的代码。

当您有多个线程访问同一个共享的、未受保护的数据时;各种事情都可能发生。

另外:仅更改您正在使用的列表类型可能还不够。你看,CopyOnWrite 列表保证了单个操作的“线程安全”。但是当你有类似的东西时

if (someList.size() > 1) {
  do something with your list

仍然不安全;即使使用 CopyOnWrite 列表 - 因为列表上有两个调用;并且列表可能会在第一次和第二次调用之间发生变化;当其他一些线程同时更改列表时。

长话短说:一种解决方案是使用不想并行运行的synchronized方法。

换句话说:添加您需要的保护;而不是通过理解线程状态模型的细节来迷惑自己——那部分不会帮助你编写正确的代码。

鉴于您的评论:您尝试在非常“低”的水平上解决这个问题。您认为您必须了解线程状态和等待条件等才能得出“好的”解决方案。但这不是一种有效的方法。特别是当你是新手并学习这些东西时。

首先,您应该担心找到正确的解决方案。然后你可以继续前进并增强它;例如通过做不同的实验。从这个意义上说,你应该明白:在真正的多线程中,我们通常会尝试从这些低级细节中抽象出来。相反,我们甚至引入了额外的层,例如Executors

我想告诉你的是:查看底层细节很可能对你没有帮助,但在这一点上会让你负担过重。

于 2017-03-20T13:34:18.983 回答
0

竞争条件可能发生在任何地方,不仅在您编写的代码中,而且在 ArrayList 的实现中。

即使以最简单的形式添加到 ArrayList 也将涉及以下操作:

  1. 读取size变量
  2. 将数据写入elementData[size]
  3. 增加size变量

当添加操作将大小增加到大于 的长度时elementData,也会发生大小调整:

  1. 制作一个 1.5 倍于当前大小的新数组elementData
  2. 将值复制elementData到新数组中
  3. 将新数组分配给elementData
  4. 将数据写入elementData[size]
  5. 增加size变量

在您的情况下,如果您将 null 添加到列表中,则可能有两个线程正在尝试同时调整数组的大小。假设目前您的列表有 10 个元素。并且elementData长度为 10。因此添加第 11 个值将调整elementData

  1. 线程 1 创建一个长度为 15 的新数组 X
  2. 线程 1 将数据复制elementData到新数组
  3. 线程 2 创建一个长度为 15 的新数组 Y
  4. elementData线程 2 将数据从新数组复制
  5. 线程 1 将 X 分配给elementData
  6. 线程 1 将值写入elementData[10]
  7. 线程 1size增加到 11
  8. 线程 2 将 Y 分配给elementData
  9. 线程 2 将值写入elementData[11]
  10. 线程 2size增加到 12
  11. elementData[10] 结果将为空

第 8 步发生的情况是线程 2 覆盖了elementData线程 1 更改的内容,因此 elementData[10](由线程 1 写入)丢失。

于 2017-03-28T17:28:10.680 回答