Java 通过引用将对象传递给线程

假设我有一个名为Object的类和一个名为ObjectCreator的线程来管理对象的创建。为了简单起见，对象具有以下属性：objectNumber和objectName

如果我要创建一个名为instance的对象实例，它将由ObjectCreator持有。现在假设我需要另一个线程（我们称之为ObjectChanger）来查看和操作实例；将实例转换为静态对象有意义吗

我通过使实例保持静态来查看结果，因此现在可以执行以下操作：

ObjectCreator.instance.getName();

其中getName（）是对象的方法。从我对类似问题的回答中所读到的，静态的东西是邪恶的，总是有解决办法的。我读过的一个建议是将实例作为构造函数的参数传递给ObjectChanger，但如果在我需要创建ObjectChanger时还没有创建实例呢

也许这个问题更多的是关于OOP的概念，而不是多线程，或者它可能是一个重复的问题，所以请原谅我，但我在这里完全迷失了方向

编辑：为了解决frankie和Jim的建议，这里有一些代码片段：

对象：

class ObjectCreator extends Thread
{
 static Object instance;

 public ObjectCreator (Object something)
 {
  instance = something;
 }

 static void createObject()
 {
  ...
 }

 static Object getObject()
 {
  return instance;
 }
}

public class ObjectChanger extends Thread
{
 private Object currentInstance = null;
 private int instanceNumber = null;

 public void run()
 {
  currentInstance = ObjectCreator.getObject(); //If I were to make getObject() non-static, this line churns up an error

  instanceNumber = currentInstance.getObjectNumber();
  currentInstance.changeNumber(2); //valid?
 }
}

类对象

{
 private String objectName = "Something";
 private int objectNumber = 1;

 public synchronized void changeNumber(int newNumber)
 {
  objectNumber = newNumber;
 }
}

ObjectCreator:

class ObjectCreator extends Thread
{
 static Object instance;

 public ObjectCreator (Object something)
 {
  instance = something;
 }

 static void createObject()
 {
  ...
 }

 static Object getObject()
 {
  return instance;
 }
}

public class ObjectChanger extends Thread
{
 private Object currentInstance = null;
 private int instanceNumber = null;

 public void run()
 {
  currentInstance = ObjectCreator.getObject(); //If I were to make getObject() non-static, this line churns up an error

  instanceNumber = currentInstance.getObjectNumber();
  currentInstance.changeNumber(2); //valid?
 }
}

ObjectChanger:

class ObjectCreator extends Thread
{
 static Object instance;

 public ObjectCreator (Object something)
 {
  instance = something;
 }

 static void createObject()
 {
  ...
 }

 static Object getObject()
 {
  return instance;
 }
}

public class ObjectChanger extends Thread
{
 private Object currentInstance = null;
 private int instanceNumber = null;

 public void run()
 {
  currentInstance = ObjectCreator.getObject(); //If I were to make getObject() non-static, this line churns up an error

  instanceNumber = currentInstance.getObjectNumber();
  currentInstance.changeNumber(2); //valid?
 }
}

---

为什么不能在ObjectCreator类中创建一个getter来检索所述对象

例如：ObjectCreater.getMyObject（）

编辑：

如果我没弄错的话，我想你在找这样的东西：

public class ObjectCreator{
    ArrayList<Object> children;

    public ObjectCreator(){ 
         children = new ArrayList<Object>();
    }

    //returns back index in children array (for accessing from other threads)
    public int createObject( whatever params here ){
       Object o = new Object( params );
       children.add(o);
       return children.size()-1;
    }

}

公共类ObjectCreator{
ArrayList儿童；
public ObjectCreator（）{
children=newarraylist（）；
}
//返回子数组中的索引（用于从其他线程访问）
public int createObject（此处的任何参数）{
对象o=新对象（参数）；
儿童。添加（o）；
返回子项。size（）-1；
}
}

---

由于我对您试图解决的问题不太了解，我不确定它是否必须是线程安全的，您是否希望映射这些对象，或者以不同的方式访问这些对象，但是我不清楚关于静态的所有困惑是从何而来的

为什么不能在ObjectCreator类中创建一个getter来检索所述对象

例如：ObjectCreater.getMyObject（）

编辑：

如果我没弄错的话，我想你在找这样的东西：

public class ObjectCreator{
    ArrayList<Object> children;

    public ObjectCreator(){ 
         children = new ArrayList<Object>();
    }

    //returns back index in children array (for accessing from other threads)
    public int createObject( whatever params here ){
       Object o = new Object( params );
       children.add(o);
       return children.size()-1;
    }

}

公共类ObjectCreator{
ArrayList儿童；
public ObjectCreator（）{
children=newarraylist（）；
}
//返回子数组中的索引（用于从其他线程访问）
public int createObject（此处的任何参数）{
对象o=新对象（参数）；
儿童。添加（o）；
返回子项。size（）-1；
}
}

---

由于我对您试图解决的问题不太了解，我不确定它是否必须是线程安全的，您是否希望映射这些对象，或者以不同的方式访问这些对象，但是我不清楚关于静态的所有困惑是从何而来的

您可以将对象放入类似

Vector

的列表结构中，并将其存储在

ObjectCreator

中。将getter方法添加到

ObjectCreator

，该方法将接受要接收的对象的索引

您可以将对象放入类似

Vector

的列表结构中，并将其存储在

ObjectCreator

中。将getter方法添加到

ObjectCreator

，该方法将接受要接收的对象的索引

这只是一个显示基本结构的框架。错误处理留作练习：-）

公共类MyObject{…}
...
公共类MyObjectCreator{
私有映射createdObjects=newHashMap（）；
公共MyObject makeNewObject（int对象，字符串对象名）
{
MyObject o=新的MyObject（对象，对象名）；
this.createdObjects.put（对象名，o）；
}
公共MyObject getObject（字符串对象名）
{
返回this.createdObjects.get（objName）；
}
}
...
公共类MyProgram{
公共静态void main（字符串[]args）
{
MyObjectCreator oc=新的MyObjectCreator（）；
MyObject mo=oc.makeNewObject（10，“aNewObject”）；
...
MyObject o=oc.get（“aNewObject”）；
...

这只是一个显示基本结构的框架。错误处理留作练习：-）

公共类MyObject{…}
...
公共类MyObjectCreator{
私有映射createdObjects=newHashMap（）；
公共MyObject makeNewObject（int对象，字符串对象名）
{
MyObject o=新的MyObject（对象，对象名）；
this.createdObjects.put（对象名，o）；
}
公共MyObject getObject（字符串对象名）
{
返回this.createdObjects.get（objName）；
}
}
...
公共类MyProgram{
公共静态void main（字符串[]args）
{
MyObjectCreator oc=新的MyObjectCreator（）；
MyObject mo=oc.makeNewObject（10，“aNewObject”）；
...
MyObject o=oc.get（“aNewObject”）；
...

如果只想更改类的字段值，只需将对象传递到新创建的线程中即可。这样就不需要在holder类中保留静态引用

---

但是，正如前面所评论的，我们需要更多的信息来了解您想要对对象和线程执行的操作。

如果您只想更改类的字段值，您应该将对象传递到新创建的线程中。这样，就不需要在holder类中保留静态引用

---

但是，正如前面所评论的，我们需要更多的信息来了解您想要对对象和线程执行的操作。

如果您希望线程能够访问未在其内部创建的对象，则必须确保所述线程具有一条它可以遵循的引用路径，从而指向新对象

考虑以下代码，不涉及线程

class MyObject { /* ... */ }

interface MyObjectProvider {
    MyObject getMyObject();
}

class Creator implements MyObjectProvider {
    private MyObject obj;
        /* ... */
    @Override
    public MyObject getMyObject() {
        return obj;
    }

    /** Invoked at some point in time. */
    void createMyObject() {
        obj = new MyObject();
    }
}

class Consumer {
    private MyObjectProvider provider;

    Consumer(MyObjectProvider mop) {
        provider = mop;
    }

    void consume() {
        // At some point in time...
        MyObject o = provider.getMyObject();
    }
}

程序示例：

public static void main(String[] args) {
    Creator creator = new Creator();
    Consumer consumer = new Consumer(creator);

    creator.createMyObject();
    consumer.consume();
}

当您向混合添加线程时，某些代码必须更改，但是