Question

我要做的是拥有一个全局变量类，函数可以读/写。

我现在拥有的是

import java.lang.*;             
import lab1.Global;
public class SecondProgram {
     public static void main ( String args[] ) {
            System.out.println("hi ");
            Global.b[0] = " zero ";
            Global.b[1] = " One ";
            Global.b[2] = " Two ";
            Global.b[3] = " Three ";

        }
}

我创建了一个存储全局变量的类

public class Global {
  public static String a = "hi" ;
  public static String [] b;
}

当然重要的是，数组的大小不是硬编码常量，而是一个我能够在某个时刻找到并插入的变量。

我希望您能从代码中看到我正在尝试做的事情，并且您知道如何使其发挥作用。

谢谢！

Answer 1

我想要全局变量，因为我有线程将文本文件中的数据读入数组，并且在线程完成其工作后，数组及其数据保持存在非常重要。

那不行。或者至少，它不能可靠（从某种意义上来说，这是一个更糟糕的结果！）

在多线程Java程序中，您需要确保线程在信息从一个传递到另一个的点处正确同步。同步的目的有两个：

防止竞争条件;即，一个线程在另一个线程读取之前尝试读取值，并且
确保线程由于内存缓存效应而看不到陈旧的值副本。

同步裸全局变量将非常困难。我的建议是

注意上面的评论，并使用类来设计和实现封装状态。
使用java.util.concurrent中的实用程序类来实现共享数据结构...并处理线程创建/管理。例如，查看ExecutorService API，
获取有关Java并发编程的优秀教科书。 Java中的并发性并不简单，如果您不知道自己在做什么，可以花费数小时/天/周/月来追踪间歇性故障的原因。

Answer 2

我认为这是一个更好的方法，可以让你开始......

import java.util.ArrayList;

public class SecondProgram {

    private static ArrayList <String>file = new ArrayList();

    public synchronized boolean  writeFile(String str){
        //wrtite file to your list
        file.add(str);
        return true;
    }
    public static void main(String args[]) {
        //read file and use the synchronized method to write it to your list
    } 
}

Answer 3

我不提倡使用全局变量，但如果必须，可以执行以下操作。通常：让每个线程建立自己的数据。完成工作后，将其数据添加到同步的全局集合（在本例中为List<List<String>>）。然后在所有线程完成工作后读取该集合。

收集数据的全局：

public class GlobalDataBroker {
    public static List<List<String>> data = Collections.synchronizedList(new LinkedList<List<String>>());
}

示例实现：

public static void main(String[] args) throws InterruptedException {
    for (int i=0; i < 10; i++) {
        new Thread(new Runnable(){
            @Override
            public void run() {
                List<String> list = new LinkedList<String>();
                list.add(String.format("I'm a Thread and my name is %s.",Thread.currentThread()));
                for (int i = 0; i < 5; i++) {
                    list.add("Data!");
                }
                GlobalDataBroker.data.add(list);
            }
        }).start();
    }

    // When the threads are done ...            
    Iterator<List<String>> i = GlobalDataBroker.data.iterator();
    while (i.hasNext()) {
        System.out.println(i.next());
    }
}

输出：

[I'm a Thread and my name is Thread[Thread-8,5,main]., Data!, Data!, Data!, Data!, Data!]
[I'm a Thread and my name is Thread[Thread-5,5,main]., Data!, Data!, Data!, Data!, Data!]
...
[I'm a Thread and my name is Thread[Thread-7,5,main]., Data!, Data!, Data!, Data!, Data!]

请注意，只有在完成编写后才能开始迭代数据。（否则，您可能会遇到可怕的ConcurrentModificationException。）

从全局变量读取和写入

3 个答案: